home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / Mesa-2.2 / src / eval.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-13  |  71.6 KB  |  2,432 lines
  1. /* $Id: eval.c,v 1.2 1996/09/15 14:17:30 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.0
  6.  * Copyright (C) 1995-1996  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: eval.c,v $
  26.  * Revision 1.2  1996/09/15 14:17:30  brianp
  27.  * now use GLframebuffer and GLvisual
  28.  *
  29.  * Revision 1.1  1996/09/13 01:38:16  brianp
  30.  * Initial revision
  31.  *
  32.  */
  33.  
  34.  
  35. /*
  36.  * eval.c was written by
  37.  * Bernd Barsuhn (bdbarsuh@cip.informatik.uni-erlangen.de) and
  38.  * Volker Weiss (vrweiss@cip.informatik.uni-erlangen.de).
  39.  *
  40.  * My original implementation of evaluators was simplistic and didn't
  41.  * compute surface normal vectors properly.  Bernd and Volker applied
  42.  * used more sophisticated methods to get better results.
  43.  *
  44.  * Thanks guys!
  45.  */
  46.  
  47.  
  48.  
  49. #include <math.h>
  50. #include <stdlib.h>
  51. #include <string.h>
  52. #include "context.h"
  53. #include "draw.h"
  54. #include "eval.h"
  55. #include "dlist.h"
  56. #include "macros.h"
  57. #include "types.h"
  58.  
  59.  
  60.  
  61. /*
  62.  * Horner scheme for Bezier curves
  63.  * 
  64.  * Bezier curves can be computed via a Horner scheme.
  65.  * Horner is numerically less stable than the de Casteljau
  66.  * algorithm, but it is faster. For curves of degree n 
  67.  * the complexity of Horner is O(n) and de Casteljau is O(n^2).
  68.  * Since stability is not important for displaying curve 
  69.  * points I decided to use the Horner scheme.
  70.  *
  71.  * A cubic Bezier curve with control points b0, b1, b2, b3 can be 
  72.  * written as
  73.  *
  74.  *        (([3]        [3]     )     [3]       )     [3]
  75.  * c(t) = (([0]*s*b0 + [1]*t*b1)*s + [2]*t^2*b2)*s + [3]*t^2*b3
  76.  *
  77.  *                                           [n]
  78.  * where s=1-t and the binomial coefficients [i]. These can 
  79.  * be computed iteratively using the identity:
  80.  *
  81.  * [n]               [n  ]             [n]
  82.  * [i] = (n-i+1)/i * [i-1]     and     [0] = 1
  83.  */
  84.  
  85. static void
  86. horner_bezier_curve(GLfloat *cp, GLfloat *out, GLfloat t,
  87.                     GLuint dim, GLuint order)
  88. {
  89.   GLfloat s, powert;
  90.   GLuint i, k, bincoeff;
  91.  
  92.   if(order >= 2)
  93.   { 
  94.     bincoeff = order-1;
  95.     s = 1.0-t;
  96.  
  97.     for(k=0; k<dim; k++)
  98.       out[k] = s*cp[k] + bincoeff*t*cp[dim+k];
  99.  
  100.     for(i=2, cp+=2*dim, powert=t*t; i<order; i++, powert*=t, cp +=dim)
  101.     {
  102.       bincoeff *= order-i;
  103.       bincoeff /= i;
  104.  
  105.       for(k=0; k<dim; k++)
  106.         out[k] = s*out[k] + bincoeff*powert*cp[k];
  107.     }
  108.   }
  109.   else /* order=1 -> constant curve */
  110.   { 
  111.     for(k=0; k<dim; k++)
  112.       out[k] = cp[k];
  113.   } 
  114. }
  115.  
  116. /*
  117.  * Tensor product Bezier surfaces
  118.  *
  119.  * Again the Horner scheme is used to compute a point on a 
  120.  * TP Bezier surface. First a control polygon for a curve
  121.  * on the surface in one parameter direction is computed,
  122.  * then the point on the curve for the other parameter 
  123.  * direction is evaluated.
  124.  *
  125.  * To store the curve control polygon additional storage
  126.  * for max(uorder,vorder) points is needed in the 
  127.  * control net cn.
  128.  */
  129.  
  130. static void
  131. horner_bezier_surf(GLfloat *cn, GLfloat *out, GLfloat u, GLfloat v,
  132.                    GLuint dim, GLuint uorder, GLuint vorder)
  133. {
  134.   GLfloat *cp = cn + uorder*vorder*dim;
  135.   GLuint i, uinc = vorder*dim;
  136.  
  137.   if(vorder > uorder)
  138.   {
  139.     if(uorder >= 2)
  140.     { 
  141.       GLfloat s, poweru;
  142.       GLuint j, k, bincoeff;
  143.  
  144.       /* Compute the control polygon for the surface-curve in u-direction */
  145.       for(j=0; j<vorder; j++)
  146.       {
  147.         GLfloat *ucp = &cn[j*dim];
  148.  
  149.         /* Each control point is the point for parameter u on a */ 
  150.         /* curve defined by the control polygons in u-direction */
  151.     bincoeff = uorder-1;
  152.     s = 1.0-u;
  153.  
  154.     for(k=0; k<dim; k++)
  155.       cp[j*dim+k] = s*ucp[k] + bincoeff*u*ucp[uinc+k];
  156.  
  157.     for(i=2, ucp+=2*uinc, poweru=u*u; i<uorder; 
  158.             i++, poweru*=u, ucp +=uinc)
  159.     {
  160.       bincoeff *= uorder-i;
  161.           bincoeff /= i;
  162.  
  163.       for(k=0; k<dim; k++)
  164.         cp[j*dim+k] = s*cp[j*dim+k] + bincoeff*poweru*ucp[k];
  165.     }
  166.       }
  167.         
  168.       /* Evaluate curve point in v */
  169.       horner_bezier_curve(cp, out, v, dim, vorder);
  170.     }
  171.     else /* uorder=1 -> cn defines a curve in v */
  172.       horner_bezier_curve(cn, out, v, dim, vorder);
  173.   }
  174.   else /* vorder <= uorder */
  175.   {
  176.     if(vorder > 1)
  177.     {
  178.       GLuint i;
  179.  
  180.       /* Compute the control polygon for the surface-curve in u-direction */
  181.       for(i=0; i<uorder; i++, cn += uinc)
  182.       {
  183.     /* For constant i all cn[i][j] (j=0..vorder) are located */
  184.     /* on consecutive memory locations, so we can use        */
  185.     /* horner_bezier_curve to compute the control points     */
  186.  
  187.     horner_bezier_curve(cn, &cp[i*dim], v, dim, vorder);
  188.       }
  189.  
  190.       /* Evaluate curve point in u */
  191.       horner_bezier_curve(cp, out, u, dim, uorder);
  192.     }
  193.     else  /* vorder=1 -> cn defines a curve in u */
  194.       horner_bezier_curve(cn, out, u, dim, uorder);
  195.   }
  196. }
  197.  
  198. /*
  199.  * The direct de Casteljau algorithm is used when a point on the
  200.  * surface and the tangent directions spanning the tangent plane
  201.  * should be computed (this is needed to compute normals to the
  202.  * surface). In this case the de Casteljau algorithm approach is
  203.  * nicer because a point and the partial derivatives can be computed 
  204.  * at the same time. To get the correct tangent length du and dv
  205.  * must be multiplied with the (u2-u1)/uorder-1 and (v2-v1)/vorder-1. 
  206.  * Since only the directions are needed, this scaling step is omitted.
  207.  *
  208.  * De Casteljau needs additional storage for uorder*vorder
  209.  * values in the control net cn.
  210.  */
  211.  
  212. static void
  213. de_casteljau_surf(GLfloat *cn, GLfloat *out, GLfloat *du, GLfloat *dv,
  214.                   GLfloat u, GLfloat v, GLuint dim, 
  215.                   GLuint uorder, GLuint vorder)
  216. {
  217.   GLfloat *dcn = cn + uorder*vorder*dim;
  218.   GLfloat us = 1.0-u, vs = 1.0-v;
  219.   GLuint h, i, j, k;
  220.   GLuint minorder = uorder < vorder ? uorder : vorder;
  221.   GLuint uinc = vorder*dim;
  222.   GLuint dcuinc = vorder;
  223.  
  224.   /* Each component is evaluated separately to save buffer space  */
  225.   /* This does not drasticaly decrease the performance of the     */
  226.   /* algorithm. If additional storage for (uorder-1)*(vorder-1)   */
  227.   /* points would be available, the components could be accessed  */
  228.   /* in the innermost loop which could lead to less cache misses. */
  229.  
  230. #define CN(I,J,K) cn[(I)*uinc+(J)*dim+(K)] 
  231. #define DCN(I, J) dcn[(I)*dcuinc+(J)]
  232.   if(minorder < 3)
  233.   {
  234.     if(uorder==vorder)
  235.     {
  236.       for(k=0; k<dim; k++)
  237.       {
  238.     /* Derivative direction in u */
  239.     du[k] = vs*(CN(1,0,k) - CN(0,0,k)) +
  240.              v*(CN(1,1,k) - CN(0,1,k));
  241.  
  242.     /* Derivative direction in v */
  243.     dv[k] = us*(CN(0,1,k) - CN(0,0,k)) + 
  244.              u*(CN(1,1,k) - CN(1,0,k));
  245.  
  246.     /* bilinear de Casteljau step */
  247.         out[k] =  us*(vs*CN(0,0,k) + v*CN(0,1,k)) +
  248.                u*(vs*CN(1,0,k) + v*CN(1,1,k));
  249.       }
  250.     }
  251.     else if(minorder == uorder)
  252.     {
  253.       for(k=0; k<dim; k++)
  254.       {
  255.     /* bilinear de Casteljau step */
  256.     DCN(1,0) =    CN(1,0,k) -   CN(0,0,k);
  257.     DCN(0,0) = us*CN(0,0,k) + u*CN(1,0,k);
  258.  
  259.     for(j=0; j<vorder-1; j++)
  260.     {
  261.       /* for the derivative in u */
  262.       DCN(1,j+1) =    CN(1,j+1,k) -   CN(0,j+1,k);
  263.       DCN(1,j)   = vs*DCN(1,j)    + v*DCN(1,j+1);
  264.  
  265.       /* for the `point' */
  266.       DCN(0,j+1) = us*CN(0,j+1,k) + u*CN(1,j+1,k);
  267.       DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
  268.     }
  269.         
  270.     /* remaining linear de Casteljau steps until the second last step */
  271.     for(h=minorder; h<vorder-1; h++)
  272.       for(j=0; j<vorder-h; j++)
  273.       {
  274.         /* for the derivative in u */
  275.         DCN(1,j) = vs*DCN(1,j) + v*DCN(1,j+1);
  276.  
  277.         /* for the `point' */
  278.         DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
  279.       }
  280.  
  281.     /* derivative direction in v */
  282.     dv[k] = DCN(0,1) - DCN(0,0);
  283.  
  284.     /* derivative direction in u */
  285.     du[k] =   vs*DCN(1,0) + v*DCN(1,1);
  286.  
  287.     /* last linear de Casteljau step */
  288.     out[k] =  vs*DCN(0,0) + v*DCN(0,1);
  289.       }
  290.     }
  291.     else /* minorder == vorder */
  292.     {
  293.       for(k=0; k<dim; k++)
  294.       {
  295.     /* bilinear de Casteljau step */
  296.     DCN(0,1) =    CN(0,1,k) -   CN(0,0,k);
  297.     DCN(0,0) = vs*CN(0,0,k) + v*CN(0,1,k);
  298.     for(i=0; i<uorder-1; i++)
  299.     {
  300.       /* for the derivative in v */
  301.       DCN(i+1,1) =    CN(i+1,1,k) -   CN(i+1,0,k);
  302.       DCN(i,1)   = us*DCN(i,1)    + u*DCN(i+1,1);
  303.  
  304.       /* for the `point' */
  305.       DCN(i+1,0) = vs*CN(i+1,0,k) + v*CN(i+1,1,k);
  306.       DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
  307.     }
  308.         
  309.     /* remaining linear de Casteljau steps until the second last step */
  310.     for(h=minorder; h<uorder-1; h++)
  311.       for(i=0; i<uorder-h; i++)
  312.       {
  313.         /* for the derivative in v */
  314.         DCN(i,1) = us*DCN(i,1) + u*DCN(i+1,1);
  315.  
  316.         /* for the `point' */
  317.         DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  318.       }
  319.  
  320.     /* derivative direction in u */
  321.     du[k] = DCN(1,0) - DCN(0,0);
  322.  
  323.     /* derivative direction in v */
  324.     dv[k] =   us*DCN(0,1) + u*DCN(1,1);
  325.  
  326.     /* last linear de Casteljau step */
  327.     out[k] =  us*DCN(0,0) + u*DCN(1,0);
  328.       }
  329.     }
  330.   }
  331.   else if(uorder == vorder)
  332.   {
  333.     for(k=0; k<dim; k++)
  334.     {
  335.       /* first bilinear de Casteljau step */
  336.       for(i=0; i<uorder-1; i++)
  337.       {
  338.     DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
  339.     for(j=0; j<vorder-1; j++)
  340.     {
  341.       DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
  342.       DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
  343.     }
  344.       }
  345.  
  346.       /* remaining bilinear de Casteljau steps until the second last step */
  347.       for(h=2; h<minorder-1; h++)
  348.     for(i=0; i<uorder-h; i++)
  349.     {
  350.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  351.       for(j=0; j<vorder-h; j++)
  352.       {
  353.         DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
  354.         DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
  355.       }
  356.     }
  357.  
  358.       /* derivative direction in u */
  359.       du[k] = vs*(DCN(1,0) - DCN(0,0)) +
  360.            v*(DCN(1,1) - DCN(0,1));
  361.  
  362.       /* derivative direction in v */
  363.       dv[k] = us*(DCN(0,1) - DCN(0,0)) + 
  364.            u*(DCN(1,1) - DCN(1,0));
  365.  
  366.       /* last bilinear de Casteljau step */
  367.       out[k] =  us*(vs*DCN(0,0) + v*DCN(0,1)) +
  368.              u*(vs*DCN(1,0) + v*DCN(1,1));
  369.     }
  370.   }
  371.   else if(minorder == uorder)
  372.   {
  373.     for(k=0; k<dim; k++)
  374.     {
  375.       /* first bilinear de Casteljau step */
  376.       for(i=0; i<uorder-1; i++)
  377.       {
  378.     DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
  379.     for(j=0; j<vorder-1; j++)
  380.     {
  381.       DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
  382.       DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
  383.     }
  384.       }
  385.  
  386.       /* remaining bilinear de Casteljau steps until the second last step */
  387.       for(h=2; h<minorder-1; h++)
  388.     for(i=0; i<uorder-h; i++)
  389.     {
  390.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  391.       for(j=0; j<vorder-h; j++)
  392.       {
  393.         DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
  394.         DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
  395.       }
  396.     }
  397.  
  398.       /* last bilinear de Casteljau step */
  399.       DCN(2,0) =    DCN(1,0) -   DCN(0,0);
  400.       DCN(0,0) = us*DCN(0,0) + u*DCN(1,0);
  401.       for(j=0; j<vorder-1; j++)
  402.       {
  403.     /* for the derivative in u */
  404.     DCN(2,j+1) =    DCN(1,j+1) -    DCN(0,j+1);
  405.     DCN(2,j)   = vs*DCN(2,j)    + v*DCN(2,j+1);
  406.     
  407.     /* for the `point' */
  408.     DCN(0,j+1) = us*DCN(0,j+1 ) + u*DCN(1,j+1);
  409.     DCN(0,j)   = vs*DCN(0,j)    + v*DCN(0,j+1);
  410.       }
  411.         
  412.       /* remaining linear de Casteljau steps until the second last step */
  413.       for(h=minorder; h<vorder-1; h++)
  414.     for(j=0; j<vorder-h; j++)
  415.     {
  416.       /* for the derivative in u */
  417.       DCN(2,j) = vs*DCN(2,j) + v*DCN(2,j+1);
  418.       
  419.       /* for the `point' */
  420.       DCN(0,j) = vs*DCN(0,j) + v*DCN(0,j+1);
  421.     }
  422.       
  423.       /* derivative direction in v */
  424.       dv[k] = DCN(0,1) - DCN(0,0);
  425.       
  426.       /* derivative direction in u */
  427.       du[k] =   vs*DCN(2,0) + v*DCN(2,1);
  428.       
  429.       /* last linear de Casteljau step */
  430.       out[k] =  vs*DCN(0,0) + v*DCN(0,1);
  431.     }
  432.   }
  433.   else /* minorder == vorder */
  434.   {
  435.     for(k=0; k<dim; k++)
  436.     {
  437.       /* first bilinear de Casteljau step */
  438.       for(i=0; i<uorder-1; i++)
  439.       {
  440.     DCN(i,0) = us*CN(i,0,k) + u*CN(i+1,0,k);
  441.     for(j=0; j<vorder-1; j++)
  442.     {
  443.       DCN(i,j+1) = us*CN(i,j+1,k) + u*CN(i+1,j+1,k);
  444.       DCN(i,j)   = vs*DCN(i,j)    + v*DCN(i,j+1);
  445.     }
  446.       }
  447.  
  448.       /* remaining bilinear de Casteljau steps until the second last step */
  449.       for(h=2; h<minorder-1; h++)
  450.     for(i=0; i<uorder-h; i++)
  451.     {
  452.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  453.       for(j=0; j<vorder-h; j++)
  454.       {
  455.         DCN(i,j+1) = us*DCN(i,j+1) + u*DCN(i+1,j+1);
  456.         DCN(i,j)   = vs*DCN(i,j)   + v*DCN(i,j+1);
  457.       }
  458.     }
  459.  
  460.       /* last bilinear de Casteljau step */
  461.       DCN(0,2) =    DCN(0,1) -   DCN(0,0);
  462.       DCN(0,0) = vs*DCN(0,0) + v*DCN(0,1);
  463.       for(i=0; i<uorder-1; i++)
  464.       {
  465.     /* for the derivative in v */
  466.     DCN(i+1,2) =    DCN(i+1,1)  -   DCN(i+1,0);
  467.     DCN(i,2)   = us*DCN(i,2)    + u*DCN(i+1,2);
  468.     
  469.     /* for the `point' */
  470.     DCN(i+1,0) = vs*DCN(i+1,0)  + v*DCN(i+1,1);
  471.     DCN(i,0)   = us*DCN(i,0)    + u*DCN(i+1,0);
  472.       }
  473.       
  474.       /* remaining linear de Casteljau steps until the second last step */
  475.       for(h=minorder; h<uorder-1; h++)
  476.     for(i=0; i<uorder-h; i++)
  477.     {
  478.       /* for the derivative in v */
  479.       DCN(i,2) = us*DCN(i,2) + u*DCN(i+1,2);
  480.       
  481.       /* for the `point' */
  482.       DCN(i,0) = us*DCN(i,0) + u*DCN(i+1,0);
  483.     }
  484.       
  485.       /* derivative direction in u */
  486.       du[k] = DCN(1,0) - DCN(0,0);
  487.       
  488.       /* derivative direction in v */
  489.       dv[k] =   us*DCN(0,2) + u*DCN(1,2);
  490.       
  491.       /* last linear de Casteljau step */
  492.       out[k] =  us*DCN(0,0) + u*DCN(1,0);
  493.     }
  494.   }
  495. #undef DCN
  496. #undef CN
  497. }
  498.  
  499. /*
  500.  * Return the number of components per control point for any type of
  501.  * evaluator.  Return 0 if bad target.
  502.  */
  503.  
  504. static GLint components( GLenum target )
  505. {
  506.    switch (target) {
  507.       case GL_MAP1_VERTEX_3:        return 3;
  508.       case GL_MAP1_VERTEX_4:        return 4;
  509.       case GL_MAP1_INDEX:        return 1;
  510.       case GL_MAP1_COLOR_4:        return 4;
  511.       case GL_MAP1_NORMAL:        return 3;
  512.       case GL_MAP1_TEXTURE_COORD_1:    return 1;
  513.       case GL_MAP1_TEXTURE_COORD_2:    return 2;
  514.       case GL_MAP1_TEXTURE_COORD_3:    return 3;
  515.       case GL_MAP1_TEXTURE_COORD_4:    return 4;
  516.       case GL_MAP2_VERTEX_3:        return 3;
  517.       case GL_MAP2_VERTEX_4:        return 4;
  518.       case GL_MAP2_INDEX:        return 1;
  519.       case GL_MAP2_COLOR_4:        return 4;
  520.       case GL_MAP2_NORMAL:        return 3;
  521.       case GL_MAP2_TEXTURE_COORD_1:    return 1;
  522.       case GL_MAP2_TEXTURE_COORD_2:    return 2;
  523.       case GL_MAP2_TEXTURE_COORD_3:    return 3;
  524.       case GL_MAP2_TEXTURE_COORD_4:    return 4;
  525.       default:                return 0;
  526.    }
  527. }
  528.  
  529.  
  530.  
  531. /*
  532.  * Do one-time initialization for evaluators.
  533.  */
  534.  
  535. void gl_init_eval( GLcontext* ctx )
  536. {
  537.   static int init_flag = 0;
  538.  
  539.   /* Compute a table of nCr (combination) values used by the
  540.    * Bernstein polynomial generator.
  541.    */
  542.  
  543.   if (init_flag==0) 
  544.   { /* no initialization needed */ 
  545.   }
  546.  
  547.   init_flag = 1;
  548. }
  549.  
  550.  
  551.  
  552. /**********************************************************************/
  553. /***            Copy and deallocate control points                  ***/
  554. /**********************************************************************/
  555.  
  556.  
  557. /*
  558.  * Copy 1-parametric evaluator control points from user-specified 
  559.  * memory space to a buffer of contiguous control points.
  560.  * Input:  see glMap1f for details
  561.  * Return:  pointer to buffer of contiguous control points or NULL if out
  562.  *          of memory.
  563.  */
  564. GLfloat *gl_copy_map_points1f( GLenum target,
  565.                                GLint ustride, GLint uorder,
  566.                                const GLfloat *points )
  567. {
  568.    GLfloat *buffer, *p;
  569.    GLuint i, k, size = components(target);
  570.  
  571.    if (!points || components==0) {
  572.       return NULL;
  573.    }
  574.  
  575.    buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
  576.  
  577.    if(buffer) 
  578.       for(i=0, p=buffer; i<uorder; i++, points+=ustride)
  579.     for(k=0; k<size; k++)
  580.       *p++ = points[k];
  581.  
  582.    return buffer;
  583. }
  584.  
  585.  
  586.  
  587. /*
  588.  * Same as above but convert doubles to floats.
  589.  */
  590. GLfloat *gl_copy_map_points1d( GLenum target,
  591.                     GLint ustride, GLint uorder,
  592.                     const GLdouble *points )
  593. {
  594.    GLfloat *buffer, *p;
  595.    GLuint i, k, size = components(target);
  596.  
  597.    buffer = (GLfloat *) malloc(uorder * size * sizeof(GLfloat));
  598.  
  599.    if(buffer)
  600.       for(i=0, p=buffer; i<uorder; i++, points+=ustride)
  601.     for(k=0; k<size; k++)
  602.       *p++ = (GLfloat) points[k];
  603.  
  604.    return buffer;
  605. }
  606.  
  607.  
  608.  
  609. /*
  610.  * Copy 2-parametric evaluator control points from user-specified 
  611.  * memory space to a buffer of contiguous control points.
  612.  * Additional memory is allocated to be used by the horner and
  613.  * de Casteljau evaluation schemes.
  614.  *
  615.  * Input:  see glMap2f for details
  616.  * Return:  pointer to buffer of contiguous control points or NULL if out
  617.  *          of memory.
  618.  */
  619. GLfloat *gl_copy_map_points2f( GLenum target,
  620.                     GLint ustride, GLint uorder,
  621.                     GLint vstride, GLint vorder,
  622.                     const GLfloat *points )
  623. {
  624.    GLfloat *buffer, *p;
  625.    GLuint i, j, k, size, dsize, hsize;
  626.    GLint uinc;
  627.  
  628.    size = components(target);
  629.  
  630.    /* max(uorder, vorder) additional points are used in      */
  631.    /* horner evaluation and uorder*vorder additional */
  632.    /* values are needed for de Casteljau                     */
  633.    dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
  634.    hsize = (uorder > vorder ? uorder : vorder)*size;
  635.  
  636.    if(hsize>dsize)
  637.      buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
  638.    else
  639.      buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
  640.  
  641.    /* compute the increment value for the u-loop */
  642.    uinc = ustride - vorder*vstride;
  643.  
  644.    if (buffer) 
  645.       for (i=0, p=buffer; i<uorder; i++, points += uinc)
  646.      for (j=0; j<vorder; j++, points += vstride)
  647.         for (k=0; k<size; k++)
  648.            *p++ = points[k];
  649.  
  650.    return buffer;
  651. }
  652.  
  653.  
  654.  
  655. /*
  656.  * Same as above but convert doubles to floats.
  657.  */
  658. GLfloat *gl_copy_map_points2d(GLenum target,
  659.                               GLint ustride, GLint uorder,
  660.                               GLint vstride, GLint vorder,
  661.                               const GLdouble *points )
  662. {
  663.    GLfloat *buffer, *p;
  664.    GLuint i, j, k, size, hsize, dsize;
  665.    GLint uinc;
  666.  
  667.    size = components(target);
  668.  
  669.    /* max(uorder, vorder) additional points are used in      */
  670.    /* horner evaluation and uorder*vorder additional */
  671.    /* values are needed for de Casteljau                     */
  672.    dsize = (uorder == 2 && vorder == 2)? 0 : uorder*vorder;
  673.    hsize = (uorder > vorder ? uorder : vorder)*size;
  674.  
  675.    if(hsize>dsize)
  676.      buffer = (GLfloat *) malloc((uorder*vorder*size+hsize)*sizeof(GLfloat));
  677.    else
  678.      buffer = (GLfloat *) malloc((uorder*vorder*size+dsize)*sizeof(GLfloat));
  679.  
  680.    /* compute the increment value for the u-loop */
  681.    uinc = ustride - vorder*vstride;
  682.  
  683.    if (buffer) 
  684.       for (i=0, p=buffer; i<uorder; i++, points += uinc)
  685.      for (j=0; j<vorder; j++, points += vstride)
  686.         for (k=0; k<size; k++)
  687.            *p++ = (GLfloat) points[k];
  688.  
  689.    return buffer;
  690. }
  691.  
  692.  
  693. /*
  694.  * This function is called by the display list deallocator function to
  695.  * specify that a given set of control points are no longer needed.
  696.  */
  697. void gl_free_control_points( GLcontext* ctx, GLenum target, GLfloat *data )
  698. {
  699.    struct gl_1d_map *map1 = NULL;
  700.    struct gl_2d_map *map2 = NULL;
  701.  
  702.    switch (target) {
  703.       case GL_MAP1_VERTEX_3:
  704.          map1 = &ctx->EvalMap.Map1Vertex3;
  705.          break;
  706.       case GL_MAP1_VERTEX_4:
  707.          map1 = &ctx->EvalMap.Map1Vertex4;
  708.      break;
  709.       case GL_MAP1_INDEX:
  710.          map1 = &ctx->EvalMap.Map1Index;
  711.          break;
  712.       case GL_MAP1_COLOR_4:
  713.          map1 = &ctx->EvalMap.Map1Color4;
  714.          break;
  715.       case GL_MAP1_NORMAL:
  716.          map1 = &ctx->EvalMap.Map1Normal;
  717.      break;
  718.       case GL_MAP1_TEXTURE_COORD_1:
  719.          map1 = &ctx->EvalMap.Map1Texture1;
  720.      break;
  721.       case GL_MAP1_TEXTURE_COORD_2:
  722.          map1 = &ctx->EvalMap.Map1Texture2;
  723.      break;
  724.       case GL_MAP1_TEXTURE_COORD_3:
  725.          map1 = &ctx->EvalMap.Map1Texture3;
  726.      break;
  727.       case GL_MAP1_TEXTURE_COORD_4:
  728.          map1 = &ctx->EvalMap.Map1Texture4;
  729.      break;
  730.       case GL_MAP2_VERTEX_3:
  731.          map2 = &ctx->EvalMap.Map2Vertex3;
  732.      break;
  733.       case GL_MAP2_VERTEX_4:
  734.          map2 = &ctx->EvalMap.Map2Vertex4;
  735.      break;
  736.       case GL_MAP2_INDEX:
  737.          map2 = &ctx->EvalMap.Map2Index;
  738.      break;
  739.       case GL_MAP2_COLOR_4:
  740.          map2 = &ctx->EvalMap.Map2Color4;
  741.          break;
  742.       case GL_MAP2_NORMAL:
  743.          map2 = &ctx->EvalMap.Map2Normal;
  744.      break;
  745.       case GL_MAP2_TEXTURE_COORD_1:
  746.          map2 = &ctx->EvalMap.Map2Texture1;
  747.      break;
  748.       case GL_MAP2_TEXTURE_COORD_2:
  749.          map2 = &ctx->EvalMap.Map2Texture2;
  750.      break;
  751.       case GL_MAP2_TEXTURE_COORD_3:
  752.          map2 = &ctx->EvalMap.Map2Texture3;
  753.      break;
  754.       case GL_MAP2_TEXTURE_COORD_4:
  755.          map2 = &ctx->EvalMap.Map2Texture4;
  756.      break;
  757.       default:
  758.      gl_error( ctx, GL_INVALID_ENUM, "gl_free_control_points" );
  759.          return;
  760.    }
  761.  
  762.    if (map1) {
  763.       if (data==map1->Points) {
  764.          /* The control points in the display list are currently */
  765.          /* being used so we can mark them as discard-able. */
  766.          map1->Retain = GL_FALSE;
  767.       }
  768.       else {
  769.          /* The control points in the display list are not currently */
  770.          /* being used. */
  771.          free( data );
  772.       }
  773.    }
  774.    if (map2) {
  775.       if (data==map2->Points) {
  776.          /* The control points in the display list are currently */
  777.          /* being used so we can mark them as discard-able. */
  778.          map2->Retain = GL_FALSE;
  779.       }
  780.       else {
  781.          /* The control points in the display list are not currently */
  782.          /* being used. */
  783.          free( data );
  784.       }
  785.    }
  786.  
  787. }
  788.  
  789.  
  790.  
  791. /**********************************************************************/
  792. /***                      API entry points                          ***/
  793. /**********************************************************************/
  794.  
  795.  
  796. /*
  797.  * Note that the array of control points must be 'unpacked' at this time.
  798.  * Input:  retain - if TRUE, this control point data is also in a display
  799.  *                  list and can't be freed until the list is freed.
  800.  */
  801. void gl_Map1f( GLcontext* ctx, GLenum target,
  802.                GLfloat u1, GLfloat u2, GLint stride,
  803.                GLint order, const GLfloat *points, GLboolean retain )
  804. {
  805.    GLuint k;
  806.  
  807.    if (!points) {
  808.       gl_error( ctx, GL_OUT_OF_MEMORY, "glMap1f" );
  809.       return;
  810.    }
  811.  
  812.    /* may be a new stride after copying control points */
  813.    stride = components( target );
  814.  
  815.    if (INSIDE_BEGIN_END(ctx)) {
  816.       gl_error( ctx, GL_INVALID_OPERATION, "glMap1" );
  817.       return;
  818.    }
  819.  
  820.    if (u1==u2) {
  821.       gl_error( ctx, GL_INVALID_VALUE, "glMap1(u1,u2)" );
  822.       return;
  823.    }
  824.  
  825.    if (order<1 || order>MAX_EVAL_ORDER) {
  826.       gl_error( ctx, GL_INVALID_VALUE, "glMap1(order)" );
  827.       return;
  828.    }
  829.  
  830.    k = components( target );
  831.    if (k==0) {
  832.       gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
  833.    }
  834.  
  835.    if (stride < k) {
  836.       gl_error( ctx, GL_INVALID_VALUE, "glMap1(stride)" );
  837.       return;
  838.    }
  839.  
  840.    switch (target) {
  841.       case GL_MAP1_VERTEX_3:
  842.          ctx->EvalMap.Map1Vertex3.Order = order;
  843.      ctx->EvalMap.Map1Vertex3.u1 = u1;
  844.      ctx->EvalMap.Map1Vertex3.u2 = u2;
  845.      if (ctx->EvalMap.Map1Vertex3.Points
  846.              && !ctx->EvalMap.Map1Vertex3.Retain) {
  847.         free( ctx->EvalMap.Map1Vertex3.Points );
  848.      }
  849.      ctx->EvalMap.Map1Vertex3.Points = (GLfloat *) points;
  850.          ctx->EvalMap.Map1Vertex3.Retain = retain;
  851.      break;
  852.       case GL_MAP1_VERTEX_4:
  853.          ctx->EvalMap.Map1Vertex4.Order = order;
  854.      ctx->EvalMap.Map1Vertex4.u1 = u1;
  855.      ctx->EvalMap.Map1Vertex4.u2 = u2;
  856.      if (ctx->EvalMap.Map1Vertex4.Points
  857.              && !ctx->EvalMap.Map1Vertex4.Retain) {
  858.         free( ctx->EvalMap.Map1Vertex4.Points );
  859.      }
  860.      ctx->EvalMap.Map1Vertex4.Points = (GLfloat *) points;
  861.      ctx->EvalMap.Map1Vertex4.Retain = retain;
  862.      break;
  863.       case GL_MAP1_INDEX:
  864.          ctx->EvalMap.Map1Index.Order = order;
  865.      ctx->EvalMap.Map1Index.u1 = u1;
  866.      ctx->EvalMap.Map1Index.u2 = u2;
  867.      if (ctx->EvalMap.Map1Index.Points
  868.              && !ctx->EvalMap.Map1Index.Retain) {
  869.         free( ctx->EvalMap.Map1Index.Points );
  870.      }
  871.      ctx->EvalMap.Map1Index.Points = (GLfloat *) points;
  872.      ctx->EvalMap.Map1Index.Retain = retain;
  873.      break;
  874.       case GL_MAP1_COLOR_4:
  875.          ctx->EvalMap.Map1Color4.Order = order;
  876.      ctx->EvalMap.Map1Color4.u1 = u1;
  877.      ctx->EvalMap.Map1Color4.u2 = u2;
  878.      if (ctx->EvalMap.Map1Color4.Points
  879.              && !ctx->EvalMap.Map1Color4.Retain) {
  880.         free( ctx->EvalMap.Map1Color4.Points );
  881.      }
  882.      ctx->EvalMap.Map1Color4.Points = (GLfloat *) points;
  883.      ctx->EvalMap.Map1Color4.Retain = retain;
  884.      break;
  885.       case GL_MAP1_NORMAL:
  886.          ctx->EvalMap.Map1Normal.Order = order;
  887.      ctx->EvalMap.Map1Normal.u1 = u1;
  888.      ctx->EvalMap.Map1Normal.u2 = u2;
  889.      if (ctx->EvalMap.Map1Normal.Points
  890.              && !ctx->EvalMap.Map1Normal.Retain) {
  891.         free( ctx->EvalMap.Map1Normal.Points );
  892.      }
  893.      ctx->EvalMap.Map1Normal.Points = (GLfloat *) points;
  894.      ctx->EvalMap.Map1Normal.Retain = retain;
  895.      break;
  896.       case GL_MAP1_TEXTURE_COORD_1:
  897.          ctx->EvalMap.Map1Texture1.Order = order;
  898.      ctx->EvalMap.Map1Texture1.u1 = u1;
  899.      ctx->EvalMap.Map1Texture1.u2 = u2;
  900.      if (ctx->EvalMap.Map1Texture1.Points
  901.              && !ctx->EvalMap.Map1Texture1.Retain) {
  902.         free( ctx->EvalMap.Map1Texture1.Points );
  903.      }
  904.      ctx->EvalMap.Map1Texture1.Points = (GLfloat *) points;
  905.      ctx->EvalMap.Map1Texture1.Retain = retain;
  906.      break;
  907.       case GL_MAP1_TEXTURE_COORD_2:
  908.          ctx->EvalMap.Map1Texture2.Order = order;
  909.      ctx->EvalMap.Map1Texture2.u1 = u1;
  910.      ctx->EvalMap.Map1Texture2.u2 = u2;
  911.      if (ctx->EvalMap.Map1Texture2.Points
  912.              && !ctx->EvalMap.Map1Texture2.Retain) {
  913.         free( ctx->EvalMap.Map1Texture2.Points );
  914.      }
  915.      ctx->EvalMap.Map1Texture2.Points = (GLfloat *) points;
  916.      ctx->EvalMap.Map1Texture2.Retain = retain;
  917.      break;
  918.       case GL_MAP1_TEXTURE_COORD_3:
  919.          ctx->EvalMap.Map1Texture3.Order = order;
  920.      ctx->EvalMap.Map1Texture3.u1 = u1;
  921.      ctx->EvalMap.Map1Texture3.u2 = u2;
  922.      if (ctx->EvalMap.Map1Texture3.Points
  923.              && !ctx->EvalMap.Map1Texture3.Retain) {
  924.         free( ctx->EvalMap.Map1Texture3.Points );
  925.      }
  926.      ctx->EvalMap.Map1Texture3.Points = (GLfloat *) points;
  927.      ctx->EvalMap.Map1Texture3.Retain = retain;
  928.      break;
  929.       case GL_MAP1_TEXTURE_COORD_4:
  930.          ctx->EvalMap.Map1Texture4.Order = order;
  931.      ctx->EvalMap.Map1Texture4.u1 = u1;
  932.      ctx->EvalMap.Map1Texture4.u2 = u2;
  933.      if (ctx->EvalMap.Map1Texture4.Points
  934.              && !ctx->EvalMap.Map1Texture4.Retain) {
  935.         free( ctx->EvalMap.Map1Texture4.Points );
  936.      }
  937.      ctx->EvalMap.Map1Texture4.Points = (GLfloat *) points;
  938.      ctx->EvalMap.Map1Texture4.Retain = retain;
  939.      break;
  940.       default:
  941.          gl_error( ctx, GL_INVALID_ENUM, "glMap1(target)" );
  942.    }
  943. }
  944.  
  945.  
  946.  
  947.  
  948. /*
  949.  * Note that the array of control points must be 'unpacked' at this time.
  950.  * Input:  retain - if TRUE, this control point data is also in a display
  951.  *                  list and can't be freed until the list is freed.
  952.  */
  953. void gl_Map2f( GLcontext* ctx, GLenum target,
  954.           GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  955.           GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  956.           const GLfloat *points, GLboolean retain )
  957. {
  958.    GLuint k;
  959.  
  960.    if (INSIDE_BEGIN_END(ctx)) {
  961.       gl_error( ctx, GL_INVALID_OPERATION, "glMap2" );
  962.       return;
  963.    }
  964.  
  965.    if (u1==u2) {
  966.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(u1,u2)" );
  967.       return;
  968.    }
  969.  
  970.    if (v1==v2) {
  971.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(v1,v2)" );
  972.       return;
  973.    }
  974.  
  975.    if (uorder<1 || uorder>MAX_EVAL_ORDER) {
  976.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(uorder)" );
  977.       return;
  978.    }
  979.  
  980.    if (vorder<1 || vorder>MAX_EVAL_ORDER) {
  981.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(vorder)" );
  982.       return;
  983.    }
  984.  
  985.    k = components( target );
  986.    if (k==0) {
  987.       gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
  988.    }
  989.  
  990.    if (ustride < k) {
  991.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(ustride)" );
  992.       return;
  993.    }
  994.    if (vstride < k) {
  995.       gl_error( ctx, GL_INVALID_VALUE, "glMap2(vstride)" );
  996.       return;
  997.    }
  998.  
  999.    switch (target) {
  1000.       case GL_MAP2_VERTEX_3:
  1001.          ctx->EvalMap.Map2Vertex3.Uorder = uorder;
  1002.      ctx->EvalMap.Map2Vertex3.u1 = u1;
  1003.      ctx->EvalMap.Map2Vertex3.u2 = u2;
  1004.          ctx->EvalMap.Map2Vertex3.Vorder = vorder;
  1005.      ctx->EvalMap.Map2Vertex3.v1 = v1;
  1006.      ctx->EvalMap.Map2Vertex3.v2 = v2;
  1007.      if (ctx->EvalMap.Map2Vertex3.Points
  1008.              && !ctx->EvalMap.Map2Vertex3.Retain) {
  1009.         free( ctx->EvalMap.Map2Vertex3.Points );
  1010.      }
  1011.      ctx->EvalMap.Map2Vertex3.Retain = retain;
  1012.      ctx->EvalMap.Map2Vertex3.Points = (GLfloat *) points;
  1013.      break;
  1014.       case GL_MAP2_VERTEX_4:
  1015.          ctx->EvalMap.Map2Vertex4.Uorder = uorder;
  1016.      ctx->EvalMap.Map2Vertex4.u1 = u1;
  1017.      ctx->EvalMap.Map2Vertex4.u2 = u2;
  1018.          ctx->EvalMap.Map2Vertex4.Vorder = vorder;
  1019.      ctx->EvalMap.Map2Vertex4.v1 = v1;
  1020.      ctx->EvalMap.Map2Vertex4.v2 = v2;
  1021.      if (ctx->EvalMap.Map2Vertex4.Points
  1022.              && !ctx->EvalMap.Map2Vertex4.Retain) {
  1023.         free( ctx->EvalMap.Map2Vertex4.Points );
  1024.      }
  1025.      ctx->EvalMap.Map2Vertex4.Points = (GLfloat *) points;
  1026.      ctx->EvalMap.Map2Vertex4.Retain = retain;
  1027.      break;
  1028.       case GL_MAP2_INDEX:
  1029.          ctx->EvalMap.Map2Index.Uorder = uorder;
  1030.      ctx->EvalMap.Map2Index.u1 = u1;
  1031.      ctx->EvalMap.Map2Index.u2 = u2;
  1032.          ctx->EvalMap.Map2Index.Vorder = vorder;
  1033.      ctx->EvalMap.Map2Index.v1 = v1;
  1034.      ctx->EvalMap.Map2Index.v2 = v2;
  1035.      if (ctx->EvalMap.Map2Index.Points
  1036.              && !ctx->EvalMap.Map2Index.Retain) {
  1037.         free( ctx->EvalMap.Map2Index.Points );
  1038.      }
  1039.      ctx->EvalMap.Map2Index.Retain = retain;
  1040.      ctx->EvalMap.Map2Index.Points = (GLfloat *) points;
  1041.      break;
  1042.       case GL_MAP2_COLOR_4:
  1043.          ctx->EvalMap.Map2Color4.Uorder = uorder;
  1044.      ctx->EvalMap.Map2Color4.u1 = u1;
  1045.      ctx->EvalMap.Map2Color4.u2 = u2;
  1046.          ctx->EvalMap.Map2Color4.Vorder = vorder;
  1047.      ctx->EvalMap.Map2Color4.v1 = v1;
  1048.      ctx->EvalMap.Map2Color4.v2 = v2;
  1049.      if (ctx->EvalMap.Map2Color4.Points
  1050.              && !ctx->EvalMap.Map2Color4.Retain) {
  1051.         free( ctx->EvalMap.Map2Color4.Points );
  1052.      }
  1053.      ctx->EvalMap.Map2Color4.Retain = retain;
  1054.      ctx->EvalMap.Map2Color4.Points = (GLfloat *) points;
  1055.      break;
  1056.       case GL_MAP2_NORMAL:
  1057.          ctx->EvalMap.Map2Normal.Uorder = uorder;
  1058.      ctx->EvalMap.Map2Normal.u1 = u1;
  1059.      ctx->EvalMap.Map2Normal.u2 = u2;
  1060.          ctx->EvalMap.Map2Normal.Vorder = vorder;
  1061.      ctx->EvalMap.Map2Normal.v1 = v1;
  1062.      ctx->EvalMap.Map2Normal.v2 = v2;
  1063.      if (ctx->EvalMap.Map2Normal.Points
  1064.              && !ctx->EvalMap.Map2Normal.Retain) {
  1065.         free( ctx->EvalMap.Map2Normal.Points );
  1066.      }
  1067.      ctx->EvalMap.Map2Normal.Retain = retain;
  1068.      ctx->EvalMap.Map2Normal.Points = (GLfloat *) points;
  1069.      break;
  1070.       case GL_MAP2_TEXTURE_COORD_1:
  1071.          ctx->EvalMap.Map2Texture1.Uorder = uorder;
  1072.      ctx->EvalMap.Map2Texture1.u1 = u1;
  1073.      ctx->EvalMap.Map2Texture1.u2 = u2;
  1074.          ctx->EvalMap.Map2Texture1.Vorder = vorder;
  1075.      ctx->EvalMap.Map2Texture1.v1 = v1;
  1076.      ctx->EvalMap.Map2Texture1.v2 = v2;
  1077.      if (ctx->EvalMap.Map2Texture1.Points
  1078.              && !ctx->EvalMap.Map2Texture1.Retain) {
  1079.         free( ctx->EvalMap.Map2Texture1.Points );
  1080.      }
  1081.      ctx->EvalMap.Map2Texture1.Retain = retain;
  1082.      ctx->EvalMap.Map2Texture1.Points = (GLfloat *) points;
  1083.      break;
  1084.       case GL_MAP2_TEXTURE_COORD_2:
  1085.          ctx->EvalMap.Map2Texture2.Uorder = uorder;
  1086.      ctx->EvalMap.Map2Texture2.u1 = u1;
  1087.      ctx->EvalMap.Map2Texture2.u2 = u2;
  1088.          ctx->EvalMap.Map2Texture2.Vorder = vorder;
  1089.      ctx->EvalMap.Map2Texture2.v1 = v1;
  1090.      ctx->EvalMap.Map2Texture2.v2 = v2;
  1091.      if (ctx->EvalMap.Map2Texture2.Points
  1092.              && !ctx->EvalMap.Map2Texture2.Retain) {
  1093.         free( ctx->EvalMap.Map2Texture2.Points );
  1094.      }
  1095.      ctx->EvalMap.Map2Texture2.Retain = retain;
  1096.      ctx->EvalMap.Map2Texture2.Points = (GLfloat *) points;
  1097.      break;
  1098.       case GL_MAP2_TEXTURE_COORD_3:
  1099.          ctx->EvalMap.Map2Texture3.Uorder = uorder;
  1100.      ctx->EvalMap.Map2Texture3.u1 = u1;
  1101.      ctx->EvalMap.Map2Texture3.u2 = u2;
  1102.          ctx->EvalMap.Map2Texture3.Vorder = vorder;
  1103.      ctx->EvalMap.Map2Texture3.v1 = v1;
  1104.      ctx->EvalMap.Map2Texture3.v2 = v2;
  1105.      if (ctx->EvalMap.Map2Texture3.Points
  1106.              && !ctx->EvalMap.Map2Texture3.Retain) {
  1107.         free( ctx->EvalMap.Map2Texture3.Points );
  1108.      }
  1109.      ctx->EvalMap.Map2Texture3.Retain = retain;
  1110.      ctx->EvalMap.Map2Texture3.Points = (GLfloat *) points;
  1111.      break;
  1112.       case GL_MAP2_TEXTURE_COORD_4:
  1113.          ctx->EvalMap.Map2Texture4.Uorder = uorder;
  1114.      ctx->EvalMap.Map2Texture4.u1 = u1;
  1115.      ctx->EvalMap.Map2Texture4.u2 = u2;
  1116.          ctx->EvalMap.Map2Texture4.Vorder = vorder;
  1117.      ctx->EvalMap.Map2Texture4.v1 = v1;
  1118.      ctx->EvalMap.Map2Texture4.v2 = v2;
  1119.      if (ctx->EvalMap.Map2Texture4.Points
  1120.              && !ctx->EvalMap.Map2Texture4.Retain) {
  1121.         free( ctx->EvalMap.Map2Texture4.Points );
  1122.      }
  1123.      ctx->EvalMap.Map2Texture4.Retain = retain;
  1124.      ctx->EvalMap.Map2Texture4.Points = (GLfloat *) points;
  1125.      break;
  1126.       default:
  1127.          gl_error( ctx, GL_INVALID_ENUM, "glMap2(target)" );
  1128.    }
  1129. }
  1130.  
  1131.  
  1132.    
  1133.  
  1134.  
  1135. void gl_GetMapdv( GLcontext* ctx, GLenum target, GLenum query, GLdouble *v )
  1136. {
  1137.    GLuint i, n;
  1138.    GLfloat *data;
  1139.  
  1140.    switch (query) {
  1141.       case GL_COEFF:
  1142.      switch (target) {
  1143.         case GL_MAP1_COLOR_4:
  1144.            data = ctx->EvalMap.Map1Color4.Points;
  1145.            n = ctx->EvalMap.Map1Color4.Order * 4;
  1146.            break;
  1147.         case GL_MAP1_INDEX:
  1148.            data = ctx->EvalMap.Map1Index.Points;
  1149.            n = ctx->EvalMap.Map1Index.Order;
  1150.            break;
  1151.         case GL_MAP1_NORMAL:
  1152.            data = ctx->EvalMap.Map1Normal.Points;
  1153.            n = ctx->EvalMap.Map1Normal.Order * 3;
  1154.            break;
  1155.         case GL_MAP1_TEXTURE_COORD_1:
  1156.            data = ctx->EvalMap.Map1Texture1.Points;
  1157.            n = ctx->EvalMap.Map1Texture1.Order * 1;
  1158.            break;
  1159.         case GL_MAP1_TEXTURE_COORD_2:
  1160.            data = ctx->EvalMap.Map1Texture2.Points;
  1161.            n = ctx->EvalMap.Map1Texture2.Order * 2;
  1162.            break;
  1163.         case GL_MAP1_TEXTURE_COORD_3:
  1164.            data = ctx->EvalMap.Map1Texture3.Points;
  1165.            n = ctx->EvalMap.Map1Texture3.Order * 3;
  1166.            break;
  1167.         case GL_MAP1_TEXTURE_COORD_4:
  1168.            data = ctx->EvalMap.Map1Texture4.Points;
  1169.            n = ctx->EvalMap.Map1Texture4.Order * 4;
  1170.            break;
  1171.         case GL_MAP1_VERTEX_3:
  1172.            data = ctx->EvalMap.Map1Vertex3.Points;
  1173.            n = ctx->EvalMap.Map1Vertex3.Order * 3;
  1174.            break;
  1175.         case GL_MAP1_VERTEX_4:
  1176.            data = ctx->EvalMap.Map1Vertex4.Points;
  1177.            n = ctx->EvalMap.Map1Vertex4.Order * 4;
  1178.            break;
  1179.         case GL_MAP2_COLOR_4:
  1180.            data = ctx->EvalMap.Map2Color4.Points;
  1181.            n = ctx->EvalMap.Map2Color4.Uorder
  1182.                  * ctx->EvalMap.Map2Color4.Vorder * 4;
  1183.            break;
  1184.         case GL_MAP2_INDEX:
  1185.            data = ctx->EvalMap.Map2Index.Points;
  1186.            n = ctx->EvalMap.Map2Index.Uorder
  1187.                  * ctx->EvalMap.Map2Index.Vorder;
  1188.            break;
  1189.         case GL_MAP2_NORMAL:
  1190.            data = ctx->EvalMap.Map2Normal.Points;
  1191.            n = ctx->EvalMap.Map2Normal.Uorder
  1192.                  * ctx->EvalMap.Map2Normal.Vorder * 3;
  1193.            break;
  1194.         case GL_MAP2_TEXTURE_COORD_1:
  1195.            data = ctx->EvalMap.Map2Texture1.Points;
  1196.            n = ctx->EvalMap.Map2Texture1.Uorder
  1197.                  * ctx->EvalMap.Map2Texture1.Vorder * 1;
  1198.            break;
  1199.         case GL_MAP2_TEXTURE_COORD_2:
  1200.            data = ctx->EvalMap.Map2Texture2.Points;
  1201.            n = ctx->EvalMap.Map2Texture2.Uorder
  1202.                  * ctx->EvalMap.Map2Texture2.Vorder * 2;
  1203.            break;
  1204.         case GL_MAP2_TEXTURE_COORD_3:
  1205.            data = ctx->EvalMap.Map2Texture3.Points;
  1206.            n = ctx->EvalMap.Map2Texture3.Uorder
  1207.                  * ctx->EvalMap.Map2Texture3.Vorder * 3;
  1208.            break;
  1209.         case GL_MAP2_TEXTURE_COORD_4:
  1210.            data = ctx->EvalMap.Map2Texture4.Points;
  1211.            n = ctx->EvalMap.Map2Texture4.Uorder
  1212.                  * ctx->EvalMap.Map2Texture4.Vorder * 4;
  1213.            break;
  1214.         case GL_MAP2_VERTEX_3:
  1215.            data = ctx->EvalMap.Map2Vertex3.Points;
  1216.            n = ctx->EvalMap.Map2Vertex3.Uorder
  1217.                  * ctx->EvalMap.Map2Vertex3.Vorder * 3;
  1218.            break;
  1219.         case GL_MAP2_VERTEX_4:
  1220.            data = ctx->EvalMap.Map2Vertex4.Points;
  1221.            n = ctx->EvalMap.Map2Vertex4.Uorder
  1222.                  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
  1223.            break;
  1224.         default:
  1225.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
  1226.      }
  1227.      if (data) {
  1228.         for (i=0;i<n;i++) {
  1229.            v[i] = data[i];
  1230.         }
  1231.      }
  1232.          break;
  1233.       case GL_ORDER:
  1234.      switch (target) {
  1235.         case GL_MAP1_COLOR_4:
  1236.            *v = ctx->EvalMap.Map1Color4.Order;
  1237.            break;
  1238.         case GL_MAP1_INDEX:
  1239.            *v = ctx->EvalMap.Map1Index.Order;
  1240.            break;
  1241.         case GL_MAP1_NORMAL:
  1242.            *v = ctx->EvalMap.Map1Normal.Order;
  1243.            break;
  1244.         case GL_MAP1_TEXTURE_COORD_1:
  1245.            *v = ctx->EvalMap.Map1Texture1.Order;
  1246.            break;
  1247.         case GL_MAP1_TEXTURE_COORD_2:
  1248.            *v = ctx->EvalMap.Map1Texture2.Order;
  1249.            break;
  1250.         case GL_MAP1_TEXTURE_COORD_3:
  1251.            *v = ctx->EvalMap.Map1Texture3.Order;
  1252.            break;
  1253.         case GL_MAP1_TEXTURE_COORD_4:
  1254.            *v = ctx->EvalMap.Map1Texture4.Order;
  1255.            break;
  1256.         case GL_MAP1_VERTEX_3:
  1257.            *v = ctx->EvalMap.Map1Vertex3.Order;
  1258.            break;
  1259.         case GL_MAP1_VERTEX_4:
  1260.            *v = ctx->EvalMap.Map1Vertex4.Order;
  1261.            break;
  1262.         case GL_MAP2_COLOR_4:
  1263.            v[0] = ctx->EvalMap.Map2Color4.Uorder;
  1264.            v[1] = ctx->EvalMap.Map2Color4.Vorder;
  1265.            break;
  1266.         case GL_MAP2_INDEX:
  1267.            v[0] = ctx->EvalMap.Map2Index.Uorder;
  1268.            v[1] = ctx->EvalMap.Map2Index.Vorder;
  1269.            break;
  1270.         case GL_MAP2_NORMAL:
  1271.            v[0] = ctx->EvalMap.Map2Normal.Uorder;
  1272.            v[1] = ctx->EvalMap.Map2Normal.Vorder;
  1273.            break;
  1274.         case GL_MAP2_TEXTURE_COORD_1:
  1275.            v[0] = ctx->EvalMap.Map2Texture1.Uorder;
  1276.            v[1] = ctx->EvalMap.Map2Texture1.Vorder;
  1277.            break;
  1278.         case GL_MAP2_TEXTURE_COORD_2:
  1279.            v[0] = ctx->EvalMap.Map2Texture2.Uorder;
  1280.            v[1] = ctx->EvalMap.Map2Texture2.Vorder;
  1281.            break;
  1282.         case GL_MAP2_TEXTURE_COORD_3:
  1283.            v[0] = ctx->EvalMap.Map2Texture3.Uorder;
  1284.            v[1] = ctx->EvalMap.Map2Texture3.Vorder;
  1285.            break;
  1286.         case GL_MAP2_TEXTURE_COORD_4:
  1287.            v[0] = ctx->EvalMap.Map2Texture4.Uorder;
  1288.            v[1] = ctx->EvalMap.Map2Texture4.Vorder;
  1289.            break;
  1290.         case GL_MAP2_VERTEX_3:
  1291.            v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
  1292.            v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
  1293.            break;
  1294.         case GL_MAP2_VERTEX_4:
  1295.            v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
  1296.            v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
  1297.            break;
  1298.         default:
  1299.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
  1300.      }
  1301.          break;
  1302.       case GL_DOMAIN:
  1303.      switch (target) {
  1304.         case GL_MAP1_COLOR_4:
  1305.            v[0] = ctx->EvalMap.Map1Color4.u1;
  1306.            v[1] = ctx->EvalMap.Map1Color4.u2;
  1307.            break;
  1308.         case GL_MAP1_INDEX:
  1309.            v[0] = ctx->EvalMap.Map1Index.u1;
  1310.            v[1] = ctx->EvalMap.Map1Index.u2;
  1311.            break;
  1312.         case GL_MAP1_NORMAL:
  1313.            v[0] = ctx->EvalMap.Map1Normal.u1;
  1314.            v[1] = ctx->EvalMap.Map1Normal.u2;
  1315.            break;
  1316.         case GL_MAP1_TEXTURE_COORD_1:
  1317.            v[0] = ctx->EvalMap.Map1Texture1.u1;
  1318.            v[1] = ctx->EvalMap.Map1Texture1.u2;
  1319.            break;
  1320.         case GL_MAP1_TEXTURE_COORD_2:
  1321.            v[0] = ctx->EvalMap.Map1Texture2.u1;
  1322.            v[1] = ctx->EvalMap.Map1Texture2.u2;
  1323.            break;
  1324.         case GL_MAP1_TEXTURE_COORD_3:
  1325.            v[0] = ctx->EvalMap.Map1Texture3.u1;
  1326.            v[1] = ctx->EvalMap.Map1Texture3.u2;
  1327.            break;
  1328.         case GL_MAP1_TEXTURE_COORD_4:
  1329.            v[0] = ctx->EvalMap.Map1Texture4.u1;
  1330.            v[1] = ctx->EvalMap.Map1Texture4.u2;
  1331.            break;
  1332.         case GL_MAP1_VERTEX_3:
  1333.            v[0] = ctx->EvalMap.Map1Vertex3.u1;
  1334.            v[1] = ctx->EvalMap.Map1Vertex3.u2;
  1335.            break;
  1336.         case GL_MAP1_VERTEX_4:
  1337.            v[0] = ctx->EvalMap.Map1Vertex4.u1;
  1338.            v[1] = ctx->EvalMap.Map1Vertex4.u2;
  1339.            break;
  1340.         case GL_MAP2_COLOR_4:
  1341.            v[0] = ctx->EvalMap.Map2Color4.u1;
  1342.            v[1] = ctx->EvalMap.Map2Color4.u2;
  1343.            v[2] = ctx->EvalMap.Map2Color4.v1;
  1344.            v[3] = ctx->EvalMap.Map2Color4.v2;
  1345.            break;
  1346.         case GL_MAP2_INDEX:
  1347.            v[0] = ctx->EvalMap.Map2Index.u1;
  1348.            v[1] = ctx->EvalMap.Map2Index.u2;
  1349.            v[2] = ctx->EvalMap.Map2Index.v1;
  1350.            v[3] = ctx->EvalMap.Map2Index.v2;
  1351.            break;
  1352.         case GL_MAP2_NORMAL:
  1353.            v[0] = ctx->EvalMap.Map2Normal.u1;
  1354.            v[1] = ctx->EvalMap.Map2Normal.u2;
  1355.            v[2] = ctx->EvalMap.Map2Normal.v1;
  1356.            v[3] = ctx->EvalMap.Map2Normal.v2;
  1357.            break;
  1358.         case GL_MAP2_TEXTURE_COORD_1:
  1359.            v[0] = ctx->EvalMap.Map2Texture1.u1;
  1360.            v[1] = ctx->EvalMap.Map2Texture1.u2;
  1361.            v[2] = ctx->EvalMap.Map2Texture1.v1;
  1362.            v[3] = ctx->EvalMap.Map2Texture1.v2;
  1363.            break;
  1364.         case GL_MAP2_TEXTURE_COORD_2:
  1365.            v[0] = ctx->EvalMap.Map2Texture2.u1;
  1366.            v[1] = ctx->EvalMap.Map2Texture2.u2;
  1367.            v[2] = ctx->EvalMap.Map2Texture2.v1;
  1368.            v[3] = ctx->EvalMap.Map2Texture2.v2;
  1369.            break;
  1370.         case GL_MAP2_TEXTURE_COORD_3:
  1371.            v[0] = ctx->EvalMap.Map2Texture3.u1;
  1372.            v[1] = ctx->EvalMap.Map2Texture3.u2;
  1373.            v[2] = ctx->EvalMap.Map2Texture3.v1;
  1374.            v[3] = ctx->EvalMap.Map2Texture3.v2;
  1375.            break;
  1376.         case GL_MAP2_TEXTURE_COORD_4:
  1377.            v[0] = ctx->EvalMap.Map2Texture4.u1;
  1378.            v[1] = ctx->EvalMap.Map2Texture4.u2;
  1379.            v[2] = ctx->EvalMap.Map2Texture4.v1;
  1380.            v[3] = ctx->EvalMap.Map2Texture4.v2;
  1381.            break;
  1382.         case GL_MAP2_VERTEX_3:
  1383.            v[0] = ctx->EvalMap.Map2Vertex3.u1;
  1384.            v[1] = ctx->EvalMap.Map2Vertex3.u2;
  1385.            v[2] = ctx->EvalMap.Map2Vertex3.v1;
  1386.            v[3] = ctx->EvalMap.Map2Vertex3.v2;
  1387.            break;
  1388.         case GL_MAP2_VERTEX_4:
  1389.            v[0] = ctx->EvalMap.Map2Vertex4.u1;
  1390.            v[1] = ctx->EvalMap.Map2Vertex4.u2;
  1391.            v[2] = ctx->EvalMap.Map2Vertex4.v1;
  1392.            v[3] = ctx->EvalMap.Map2Vertex4.v2;
  1393.            break;
  1394.         default:
  1395.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(target)" );
  1396.      }
  1397.          break;
  1398.       default:
  1399.          gl_error( ctx, GL_INVALID_ENUM, "glGetMapdv(query)" );
  1400.    }
  1401. }
  1402.  
  1403.  
  1404. void gl_GetMapfv( GLcontext* ctx, GLenum target, GLenum query, GLfloat *v )
  1405. {
  1406.    GLuint i, n;
  1407.    GLfloat *data;
  1408.  
  1409.    switch (query) {
  1410.       case GL_COEFF:
  1411.      switch (target) {
  1412.         case GL_MAP1_COLOR_4:
  1413.            data = ctx->EvalMap.Map1Color4.Points;
  1414.            n = ctx->EvalMap.Map1Color4.Order * 4;
  1415.            break;
  1416.         case GL_MAP1_INDEX:
  1417.            data = ctx->EvalMap.Map1Index.Points;
  1418.            n = ctx->EvalMap.Map1Index.Order;
  1419.            break;
  1420.         case GL_MAP1_NORMAL:
  1421.            data = ctx->EvalMap.Map1Normal.Points;
  1422.            n = ctx->EvalMap.Map1Normal.Order * 3;
  1423.            break;
  1424.         case GL_MAP1_TEXTURE_COORD_1:
  1425.            data = ctx->EvalMap.Map1Texture1.Points;
  1426.            n = ctx->EvalMap.Map1Texture1.Order * 1;
  1427.            break;
  1428.         case GL_MAP1_TEXTURE_COORD_2:
  1429.            data = ctx->EvalMap.Map1Texture2.Points;
  1430.            n = ctx->EvalMap.Map1Texture2.Order * 2;
  1431.            break;
  1432.         case GL_MAP1_TEXTURE_COORD_3:
  1433.            data = ctx->EvalMap.Map1Texture3.Points;
  1434.            n = ctx->EvalMap.Map1Texture3.Order * 3;
  1435.            break;
  1436.         case GL_MAP1_TEXTURE_COORD_4:
  1437.            data = ctx->EvalMap.Map1Texture4.Points;
  1438.            n = ctx->EvalMap.Map1Texture4.Order * 4;
  1439.            break;
  1440.         case GL_MAP1_VERTEX_3:
  1441.            data = ctx->EvalMap.Map1Vertex3.Points;
  1442.            n = ctx->EvalMap.Map1Vertex3.Order * 3;
  1443.            break;
  1444.         case GL_MAP1_VERTEX_4:
  1445.            data = ctx->EvalMap.Map1Vertex4.Points;
  1446.            n = ctx->EvalMap.Map1Vertex4.Order * 4;
  1447.            break;
  1448.         case GL_MAP2_COLOR_4:
  1449.            data = ctx->EvalMap.Map2Color4.Points;
  1450.            n = ctx->EvalMap.Map2Color4.Uorder
  1451.                  * ctx->EvalMap.Map2Color4.Vorder * 4;
  1452.            break;
  1453.         case GL_MAP2_INDEX:
  1454.            data = ctx->EvalMap.Map2Index.Points;
  1455.            n = ctx->EvalMap.Map2Index.Uorder
  1456.                  * ctx->EvalMap.Map2Index.Vorder;
  1457.            break;
  1458.         case GL_MAP2_NORMAL:
  1459.            data = ctx->EvalMap.Map2Normal.Points;
  1460.            n = ctx->EvalMap.Map2Normal.Uorder
  1461.                  * ctx->EvalMap.Map2Normal.Vorder * 3;
  1462.            break;
  1463.         case GL_MAP2_TEXTURE_COORD_1:
  1464.            data = ctx->EvalMap.Map2Texture1.Points;
  1465.            n = ctx->EvalMap.Map2Texture1.Uorder
  1466.                  * ctx->EvalMap.Map2Texture1.Vorder * 1;
  1467.            break;
  1468.         case GL_MAP2_TEXTURE_COORD_2:
  1469.            data = ctx->EvalMap.Map2Texture2.Points;
  1470.            n = ctx->EvalMap.Map2Texture2.Uorder
  1471.                  * ctx->EvalMap.Map2Texture2.Vorder * 2;
  1472.            break;
  1473.         case GL_MAP2_TEXTURE_COORD_3:
  1474.            data = ctx->EvalMap.Map2Texture3.Points;
  1475.            n = ctx->EvalMap.Map2Texture3.Uorder
  1476.                  * ctx->EvalMap.Map2Texture3.Vorder * 3;
  1477.            break;
  1478.         case GL_MAP2_TEXTURE_COORD_4:
  1479.            data = ctx->EvalMap.Map2Texture4.Points;
  1480.            n = ctx->EvalMap.Map2Texture4.Uorder
  1481.                  * ctx->EvalMap.Map2Texture4.Vorder * 4;
  1482.            break;
  1483.         case GL_MAP2_VERTEX_3:
  1484.            data = ctx->EvalMap.Map2Vertex3.Points;
  1485.            n = ctx->EvalMap.Map2Vertex3.Uorder
  1486.                  * ctx->EvalMap.Map2Vertex3.Vorder * 3;
  1487.            break;
  1488.         case GL_MAP2_VERTEX_4:
  1489.            data = ctx->EvalMap.Map2Vertex4.Points;
  1490.            n = ctx->EvalMap.Map2Vertex4.Uorder
  1491.                  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
  1492.            break;
  1493.         default:
  1494.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
  1495.      }
  1496.      if (data) {
  1497.         for (i=0;i<n;i++) {
  1498.            v[i] = data[i];
  1499.         }
  1500.      }
  1501.          break;
  1502.       case GL_ORDER:
  1503.      switch (target) {
  1504.         case GL_MAP1_COLOR_4:
  1505.            *v = ctx->EvalMap.Map1Color4.Order;
  1506.            break;
  1507.         case GL_MAP1_INDEX:
  1508.            *v = ctx->EvalMap.Map1Index.Order;
  1509.            break;
  1510.         case GL_MAP1_NORMAL:
  1511.            *v = ctx->EvalMap.Map1Normal.Order;
  1512.            break;
  1513.         case GL_MAP1_TEXTURE_COORD_1:
  1514.            *v = ctx->EvalMap.Map1Texture1.Order;
  1515.            break;
  1516.         case GL_MAP1_TEXTURE_COORD_2:
  1517.            *v = ctx->EvalMap.Map1Texture2.Order;
  1518.            break;
  1519.         case GL_MAP1_TEXTURE_COORD_3:
  1520.            *v = ctx->EvalMap.Map1Texture3.Order;
  1521.            break;
  1522.         case GL_MAP1_TEXTURE_COORD_4:
  1523.            *v = ctx->EvalMap.Map1Texture4.Order;
  1524.            break;
  1525.         case GL_MAP1_VERTEX_3:
  1526.            *v = ctx->EvalMap.Map1Vertex3.Order;
  1527.            break;
  1528.         case GL_MAP1_VERTEX_4:
  1529.            *v = ctx->EvalMap.Map1Vertex4.Order;
  1530.            break;
  1531.         case GL_MAP2_COLOR_4:
  1532.            v[0] = ctx->EvalMap.Map2Color4.Uorder;
  1533.            v[1] = ctx->EvalMap.Map2Color4.Vorder;
  1534.            break;
  1535.         case GL_MAP2_INDEX:
  1536.            v[0] = ctx->EvalMap.Map2Index.Uorder;
  1537.            v[1] = ctx->EvalMap.Map2Index.Vorder;
  1538.            break;
  1539.         case GL_MAP2_NORMAL:
  1540.            v[0] = ctx->EvalMap.Map2Normal.Uorder;
  1541.            v[1] = ctx->EvalMap.Map2Normal.Vorder;
  1542.            break;
  1543.         case GL_MAP2_TEXTURE_COORD_1:
  1544.            v[0] = ctx->EvalMap.Map2Texture1.Uorder;
  1545.            v[1] = ctx->EvalMap.Map2Texture1.Vorder;
  1546.            break;
  1547.         case GL_MAP2_TEXTURE_COORD_2:
  1548.            v[0] = ctx->EvalMap.Map2Texture2.Uorder;
  1549.            v[1] = ctx->EvalMap.Map2Texture2.Vorder;
  1550.            break;
  1551.         case GL_MAP2_TEXTURE_COORD_3:
  1552.            v[0] = ctx->EvalMap.Map2Texture3.Uorder;
  1553.            v[1] = ctx->EvalMap.Map2Texture3.Vorder;
  1554.            break;
  1555.         case GL_MAP2_TEXTURE_COORD_4:
  1556.            v[0] = ctx->EvalMap.Map2Texture4.Uorder;
  1557.            v[1] = ctx->EvalMap.Map2Texture4.Vorder;
  1558.            break;
  1559.         case GL_MAP2_VERTEX_3:
  1560.            v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
  1561.            v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
  1562.            break;
  1563.         case GL_MAP2_VERTEX_4:
  1564.            v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
  1565.            v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
  1566.            break;
  1567.         default:
  1568.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
  1569.      }
  1570.          break;
  1571.       case GL_DOMAIN:
  1572.      switch (target) {
  1573.         case GL_MAP1_COLOR_4:
  1574.            v[0] = ctx->EvalMap.Map1Color4.u1;
  1575.            v[1] = ctx->EvalMap.Map1Color4.u2;
  1576.            break;
  1577.         case GL_MAP1_INDEX:
  1578.            v[0] = ctx->EvalMap.Map1Index.u1;
  1579.            v[1] = ctx->EvalMap.Map1Index.u2;
  1580.            break;
  1581.         case GL_MAP1_NORMAL:
  1582.            v[0] = ctx->EvalMap.Map1Normal.u1;
  1583.            v[1] = ctx->EvalMap.Map1Normal.u2;
  1584.            break;
  1585.         case GL_MAP1_TEXTURE_COORD_1:
  1586.            v[0] = ctx->EvalMap.Map1Texture1.u1;
  1587.            v[1] = ctx->EvalMap.Map1Texture1.u2;
  1588.            break;
  1589.         case GL_MAP1_TEXTURE_COORD_2:
  1590.            v[0] = ctx->EvalMap.Map1Texture2.u1;
  1591.            v[1] = ctx->EvalMap.Map1Texture2.u2;
  1592.            break;
  1593.         case GL_MAP1_TEXTURE_COORD_3:
  1594.            v[0] = ctx->EvalMap.Map1Texture3.u1;
  1595.            v[1] = ctx->EvalMap.Map1Texture3.u2;
  1596.            break;
  1597.         case GL_MAP1_TEXTURE_COORD_4:
  1598.            v[0] = ctx->EvalMap.Map1Texture4.u1;
  1599.            v[1] = ctx->EvalMap.Map1Texture4.u2;
  1600.            break;
  1601.         case GL_MAP1_VERTEX_3:
  1602.            v[0] = ctx->EvalMap.Map1Vertex3.u1;
  1603.            v[1] = ctx->EvalMap.Map1Vertex3.u2;
  1604.            break;
  1605.         case GL_MAP1_VERTEX_4:
  1606.            v[0] = ctx->EvalMap.Map1Vertex4.u1;
  1607.            v[1] = ctx->EvalMap.Map1Vertex4.u2;
  1608.            break;
  1609.         case GL_MAP2_COLOR_4:
  1610.            v[0] = ctx->EvalMap.Map2Color4.u1;
  1611.            v[1] = ctx->EvalMap.Map2Color4.u2;
  1612.            v[2] = ctx->EvalMap.Map2Color4.v1;
  1613.            v[3] = ctx->EvalMap.Map2Color4.v2;
  1614.            break;
  1615.         case GL_MAP2_INDEX:
  1616.            v[0] = ctx->EvalMap.Map2Index.u1;
  1617.            v[1] = ctx->EvalMap.Map2Index.u2;
  1618.            v[2] = ctx->EvalMap.Map2Index.v1;
  1619.            v[3] = ctx->EvalMap.Map2Index.v2;
  1620.            break;
  1621.         case GL_MAP2_NORMAL:
  1622.            v[0] = ctx->EvalMap.Map2Normal.u1;
  1623.            v[1] = ctx->EvalMap.Map2Normal.u2;
  1624.            v[2] = ctx->EvalMap.Map2Normal.v1;
  1625.            v[3] = ctx->EvalMap.Map2Normal.v2;
  1626.            break;
  1627.         case GL_MAP2_TEXTURE_COORD_1:
  1628.            v[0] = ctx->EvalMap.Map2Texture1.u1;
  1629.            v[1] = ctx->EvalMap.Map2Texture1.u2;
  1630.            v[2] = ctx->EvalMap.Map2Texture1.v1;
  1631.            v[3] = ctx->EvalMap.Map2Texture1.v2;
  1632.            break;
  1633.         case GL_MAP2_TEXTURE_COORD_2:
  1634.            v[0] = ctx->EvalMap.Map2Texture2.u1;
  1635.            v[1] = ctx->EvalMap.Map2Texture2.u2;
  1636.            v[2] = ctx->EvalMap.Map2Texture2.v1;
  1637.            v[3] = ctx->EvalMap.Map2Texture2.v2;
  1638.            break;
  1639.         case GL_MAP2_TEXTURE_COORD_3:
  1640.            v[0] = ctx->EvalMap.Map2Texture3.u1;
  1641.            v[1] = ctx->EvalMap.Map2Texture3.u2;
  1642.            v[2] = ctx->EvalMap.Map2Texture3.v1;
  1643.            v[3] = ctx->EvalMap.Map2Texture3.v2;
  1644.            break;
  1645.         case GL_MAP2_TEXTURE_COORD_4:
  1646.            v[0] = ctx->EvalMap.Map2Texture4.u1;
  1647.            v[1] = ctx->EvalMap.Map2Texture4.u2;
  1648.            v[2] = ctx->EvalMap.Map2Texture4.v1;
  1649.            v[3] = ctx->EvalMap.Map2Texture4.v2;
  1650.            break;
  1651.         case GL_MAP2_VERTEX_3:
  1652.            v[0] = ctx->EvalMap.Map2Vertex3.u1;
  1653.            v[1] = ctx->EvalMap.Map2Vertex3.u2;
  1654.            v[2] = ctx->EvalMap.Map2Vertex3.v1;
  1655.            v[3] = ctx->EvalMap.Map2Vertex3.v2;
  1656.            break;
  1657.         case GL_MAP2_VERTEX_4:
  1658.            v[0] = ctx->EvalMap.Map2Vertex4.u1;
  1659.            v[1] = ctx->EvalMap.Map2Vertex4.u2;
  1660.            v[2] = ctx->EvalMap.Map2Vertex4.v1;
  1661.            v[3] = ctx->EvalMap.Map2Vertex4.v2;
  1662.            break;
  1663.         default:
  1664.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(target)" );
  1665.      }
  1666.          break;
  1667.       default:
  1668.          gl_error( ctx, GL_INVALID_ENUM, "glGetMapfv(query)" );
  1669.    }
  1670. }
  1671.  
  1672.  
  1673. void gl_GetMapiv( GLcontext* ctx, GLenum target, GLenum query, GLint *v )
  1674. {
  1675.    GLuint i, n;
  1676.    GLfloat *data;
  1677.  
  1678.    switch (query) {
  1679.       case GL_COEFF:
  1680.      switch (target) {
  1681.         case GL_MAP1_COLOR_4:
  1682.            data = ctx->EvalMap.Map1Color4.Points;
  1683.            n = ctx->EvalMap.Map1Color4.Order * 4;
  1684.            break;
  1685.         case GL_MAP1_INDEX:
  1686.            data = ctx->EvalMap.Map1Index.Points;
  1687.            n = ctx->EvalMap.Map1Index.Order;
  1688.            break;
  1689.         case GL_MAP1_NORMAL:
  1690.            data = ctx->EvalMap.Map1Normal.Points;
  1691.            n = ctx->EvalMap.Map1Normal.Order * 3;
  1692.            break;
  1693.         case GL_MAP1_TEXTURE_COORD_1:
  1694.            data = ctx->EvalMap.Map1Texture1.Points;
  1695.            n = ctx->EvalMap.Map1Texture1.Order * 1;
  1696.            break;
  1697.         case GL_MAP1_TEXTURE_COORD_2:
  1698.            data = ctx->EvalMap.Map1Texture2.Points;
  1699.            n = ctx->EvalMap.Map1Texture2.Order * 2;
  1700.            break;
  1701.         case GL_MAP1_TEXTURE_COORD_3:
  1702.            data = ctx->EvalMap.Map1Texture3.Points;
  1703.            n = ctx->EvalMap.Map1Texture3.Order * 3;
  1704.            break;
  1705.         case GL_MAP1_TEXTURE_COORD_4:
  1706.            data = ctx->EvalMap.Map1Texture4.Points;
  1707.            n = ctx->EvalMap.Map1Texture4.Order * 4;
  1708.            break;
  1709.         case GL_MAP1_VERTEX_3:
  1710.            data = ctx->EvalMap.Map1Vertex3.Points;
  1711.            n = ctx->EvalMap.Map1Vertex3.Order * 3;
  1712.            break;
  1713.         case GL_MAP1_VERTEX_4:
  1714.            data = ctx->EvalMap.Map1Vertex4.Points;
  1715.            n = ctx->EvalMap.Map1Vertex4.Order * 4;
  1716.            break;
  1717.         case GL_MAP2_COLOR_4:
  1718.            data = ctx->EvalMap.Map2Color4.Points;
  1719.            n = ctx->EvalMap.Map2Color4.Uorder
  1720.                  * ctx->EvalMap.Map2Color4.Vorder * 4;
  1721.            break;
  1722.         case GL_MAP2_INDEX:
  1723.            data = ctx->EvalMap.Map2Index.Points;
  1724.            n = ctx->EvalMap.Map2Index.Uorder
  1725.                  * ctx->EvalMap.Map2Index.Vorder;
  1726.            break;
  1727.         case GL_MAP2_NORMAL:
  1728.            data = ctx->EvalMap.Map2Normal.Points;
  1729.            n = ctx->EvalMap.Map2Normal.Uorder
  1730.                  * ctx->EvalMap.Map2Normal.Vorder * 3;
  1731.            break;
  1732.         case GL_MAP2_TEXTURE_COORD_1:
  1733.            data = ctx->EvalMap.Map2Texture1.Points;
  1734.            n = ctx->EvalMap.Map2Texture1.Uorder
  1735.                  * ctx->EvalMap.Map2Texture1.Vorder * 1;
  1736.            break;
  1737.         case GL_MAP2_TEXTURE_COORD_2:
  1738.            data = ctx->EvalMap.Map2Texture2.Points;
  1739.            n = ctx->EvalMap.Map2Texture2.Uorder
  1740.                  * ctx->EvalMap.Map2Texture2.Vorder * 2;
  1741.            break;
  1742.         case GL_MAP2_TEXTURE_COORD_3:
  1743.            data = ctx->EvalMap.Map2Texture3.Points;
  1744.            n = ctx->EvalMap.Map2Texture3.Uorder
  1745.                  * ctx->EvalMap.Map2Texture3.Vorder * 3;
  1746.            break;
  1747.         case GL_MAP2_TEXTURE_COORD_4:
  1748.            data = ctx->EvalMap.Map2Texture4.Points;
  1749.            n = ctx->EvalMap.Map2Texture4.Uorder
  1750.                  * ctx->EvalMap.Map2Texture4.Vorder * 4;
  1751.            break;
  1752.         case GL_MAP2_VERTEX_3:
  1753.            data = ctx->EvalMap.Map2Vertex3.Points;
  1754.            n = ctx->EvalMap.Map2Vertex3.Uorder
  1755.                  * ctx->EvalMap.Map2Vertex3.Vorder * 3;
  1756.            break;
  1757.         case GL_MAP2_VERTEX_4:
  1758.            data = ctx->EvalMap.Map2Vertex4.Points;
  1759.            n = ctx->EvalMap.Map2Vertex4.Uorder
  1760.                  * ctx->EvalMap.Map2Vertex4.Vorder * 4;
  1761.            break;
  1762.         default:
  1763.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
  1764.      }
  1765.      if (data) {
  1766.         for (i=0;i<n;i++) {
  1767.            v[i] = ROUNDF(data[i]);
  1768.         }
  1769.      }
  1770.          break;
  1771.       case GL_ORDER:
  1772.      switch (target) {
  1773.         case GL_MAP1_COLOR_4:
  1774.            *v = ctx->EvalMap.Map1Color4.Order;
  1775.            break;
  1776.         case GL_MAP1_INDEX:
  1777.            *v = ctx->EvalMap.Map1Index.Order;
  1778.            break;
  1779.         case GL_MAP1_NORMAL:
  1780.            *v = ctx->EvalMap.Map1Normal.Order;
  1781.            break;
  1782.         case GL_MAP1_TEXTURE_COORD_1:
  1783.            *v = ctx->EvalMap.Map1Texture1.Order;
  1784.            break;
  1785.         case GL_MAP1_TEXTURE_COORD_2:
  1786.            *v = ctx->EvalMap.Map1Texture2.Order;
  1787.            break;
  1788.         case GL_MAP1_TEXTURE_COORD_3:
  1789.            *v = ctx->EvalMap.Map1Texture3.Order;
  1790.            break;
  1791.         case GL_MAP1_TEXTURE_COORD_4:
  1792.            *v = ctx->EvalMap.Map1Texture4.Order;
  1793.            break;
  1794.         case GL_MAP1_VERTEX_3:
  1795.            *v = ctx->EvalMap.Map1Vertex3.Order;
  1796.            break;
  1797.         case GL_MAP1_VERTEX_4:
  1798.            *v = ctx->EvalMap.Map1Vertex4.Order;
  1799.            break;
  1800.         case GL_MAP2_COLOR_4:
  1801.            v[0] = ctx->EvalMap.Map2Color4.Uorder;
  1802.            v[1] = ctx->EvalMap.Map2Color4.Vorder;
  1803.            break;
  1804.         case GL_MAP2_INDEX:
  1805.            v[0] = ctx->EvalMap.Map2Index.Uorder;
  1806.            v[1] = ctx->EvalMap.Map2Index.Vorder;
  1807.            break;
  1808.         case GL_MAP2_NORMAL:
  1809.            v[0] = ctx->EvalMap.Map2Normal.Uorder;
  1810.            v[1] = ctx->EvalMap.Map2Normal.Vorder;
  1811.            break;
  1812.         case GL_MAP2_TEXTURE_COORD_1:
  1813.            v[0] = ctx->EvalMap.Map2Texture1.Uorder;
  1814.            v[1] = ctx->EvalMap.Map2Texture1.Vorder;
  1815.            break;
  1816.         case GL_MAP2_TEXTURE_COORD_2:
  1817.            v[0] = ctx->EvalMap.Map2Texture2.Uorder;
  1818.            v[1] = ctx->EvalMap.Map2Texture2.Vorder;
  1819.            break;
  1820.         case GL_MAP2_TEXTURE_COORD_3:
  1821.            v[0] = ctx->EvalMap.Map2Texture3.Uorder;
  1822.            v[1] = ctx->EvalMap.Map2Texture3.Vorder;
  1823.            break;
  1824.         case GL_MAP2_TEXTURE_COORD_4:
  1825.            v[0] = ctx->EvalMap.Map2Texture4.Uorder;
  1826.            v[1] = ctx->EvalMap.Map2Texture4.Vorder;
  1827.            break;
  1828.         case GL_MAP2_VERTEX_3:
  1829.            v[0] = ctx->EvalMap.Map2Vertex3.Uorder;
  1830.            v[1] = ctx->EvalMap.Map2Vertex3.Vorder;
  1831.            break;
  1832.         case GL_MAP2_VERTEX_4:
  1833.            v[0] = ctx->EvalMap.Map2Vertex4.Uorder;
  1834.            v[1] = ctx->EvalMap.Map2Vertex4.Vorder;
  1835.            break;
  1836.         default:
  1837.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
  1838.      }
  1839.          break;
  1840.       case GL_DOMAIN:
  1841.      switch (target) {
  1842.         case GL_MAP1_COLOR_4:
  1843.            v[0] = ROUNDF(ctx->EvalMap.Map1Color4.u1);
  1844.            v[1] = ROUNDF(ctx->EvalMap.Map1Color4.u2);
  1845.            break;
  1846.         case GL_MAP1_INDEX:
  1847.            v[0] = ROUNDF(ctx->EvalMap.Map1Index.u1);
  1848.            v[1] = ROUNDF(ctx->EvalMap.Map1Index.u2);
  1849.            break;
  1850.         case GL_MAP1_NORMAL:
  1851.            v[0] = ROUNDF(ctx->EvalMap.Map1Normal.u1);
  1852.            v[1] = ROUNDF(ctx->EvalMap.Map1Normal.u2);
  1853.            break;
  1854.         case GL_MAP1_TEXTURE_COORD_1:
  1855.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture1.u1);
  1856.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture1.u2);
  1857.            break;
  1858.         case GL_MAP1_TEXTURE_COORD_2:
  1859.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture2.u1);
  1860.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture2.u2);
  1861.            break;
  1862.         case GL_MAP1_TEXTURE_COORD_3:
  1863.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture3.u1);
  1864.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture3.u2);
  1865.            break;
  1866.         case GL_MAP1_TEXTURE_COORD_4:
  1867.            v[0] = ROUNDF(ctx->EvalMap.Map1Texture4.u1);
  1868.            v[1] = ROUNDF(ctx->EvalMap.Map1Texture4.u2);
  1869.            break;
  1870.         case GL_MAP1_VERTEX_3:
  1871.            v[0] = ROUNDF(ctx->EvalMap.Map1Vertex3.u1);
  1872.            v[1] = ROUNDF(ctx->EvalMap.Map1Vertex3.u2);
  1873.            break;
  1874.         case GL_MAP1_VERTEX_4:
  1875.            v[0] = ROUNDF(ctx->EvalMap.Map1Vertex4.u1);
  1876.            v[1] = ROUNDF(ctx->EvalMap.Map1Vertex4.u2);
  1877.            break;
  1878.         case GL_MAP2_COLOR_4:
  1879.            v[0] = ROUNDF(ctx->EvalMap.Map2Color4.u1);
  1880.            v[1] = ROUNDF(ctx->EvalMap.Map2Color4.u2);
  1881.            v[2] = ROUNDF(ctx->EvalMap.Map2Color4.v1);
  1882.            v[3] = ROUNDF(ctx->EvalMap.Map2Color4.v2);
  1883.            break;
  1884.         case GL_MAP2_INDEX:
  1885.            v[0] = ROUNDF(ctx->EvalMap.Map2Index.u1);
  1886.            v[1] = ROUNDF(ctx->EvalMap.Map2Index.u2);
  1887.            v[2] = ROUNDF(ctx->EvalMap.Map2Index.v1);
  1888.            v[3] = ROUNDF(ctx->EvalMap.Map2Index.v2);
  1889.            break;
  1890.         case GL_MAP2_NORMAL:
  1891.            v[0] = ROUNDF(ctx->EvalMap.Map2Normal.u1);
  1892.            v[1] = ROUNDF(ctx->EvalMap.Map2Normal.u2);
  1893.            v[2] = ROUNDF(ctx->EvalMap.Map2Normal.v1);
  1894.            v[3] = ROUNDF(ctx->EvalMap.Map2Normal.v2);
  1895.            break;
  1896.         case GL_MAP2_TEXTURE_COORD_1:
  1897.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture1.u1);
  1898.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture1.u2);
  1899.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture1.v1);
  1900.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture1.v2);
  1901.            break;
  1902.         case GL_MAP2_TEXTURE_COORD_2:
  1903.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture2.u1);
  1904.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture2.u2);
  1905.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture2.v1);
  1906.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture2.v2);
  1907.            break;
  1908.         case GL_MAP2_TEXTURE_COORD_3:
  1909.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture3.u1);
  1910.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture3.u2);
  1911.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture3.v1);
  1912.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture3.v2);
  1913.            break;
  1914.         case GL_MAP2_TEXTURE_COORD_4:
  1915.            v[0] = ROUNDF(ctx->EvalMap.Map2Texture4.u1);
  1916.            v[1] = ROUNDF(ctx->EvalMap.Map2Texture4.u2);
  1917.            v[2] = ROUNDF(ctx->EvalMap.Map2Texture4.v1);
  1918.            v[3] = ROUNDF(ctx->EvalMap.Map2Texture4.v2);
  1919.            break;
  1920.         case GL_MAP2_VERTEX_3:
  1921.            v[0] = ROUNDF(ctx->EvalMap.Map2Vertex3.u1);
  1922.            v[1] = ROUNDF(ctx->EvalMap.Map2Vertex3.u2);
  1923.            v[2] = ROUNDF(ctx->EvalMap.Map2Vertex3.v1);
  1924.            v[3] = ROUNDF(ctx->EvalMap.Map2Vertex3.v2);
  1925.            break;
  1926.         case GL_MAP2_VERTEX_4:
  1927.            v[0] = ROUNDF(ctx->EvalMap.Map2Vertex4.u1);
  1928.            v[1] = ROUNDF(ctx->EvalMap.Map2Vertex4.u2);
  1929.            v[2] = ROUNDF(ctx->EvalMap.Map2Vertex4.v1);
  1930.            v[3] = ROUNDF(ctx->EvalMap.Map2Vertex4.v2);
  1931.            break;
  1932.         default:
  1933.            gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(target)" );
  1934.      }
  1935.          break;
  1936.       default:
  1937.          gl_error( ctx, GL_INVALID_ENUM, "glGetMapiv(query)" );
  1938.    }
  1939. }
  1940.  
  1941.  
  1942.  
  1943. void gl_EvalCoord1f(GLcontext* ctx, GLfloat u)
  1944. {
  1945.   GLfloat vertex[4];
  1946.   GLfloat normal[3];
  1947.   GLfloat fcolor[4];
  1948.   GLint icolor[4];
  1949.   GLint *colorptr;
  1950.   GLfloat texcoord[4];
  1951.   GLuint index;
  1952.   register GLfloat uu;
  1953.  
  1954.   /** Vertex **/
  1955.   if (ctx->Eval.Map1Vertex4) 
  1956.   {
  1957.      struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex4;
  1958.      uu = (u - map->u1) / (map->u2 - map->u1);
  1959.      horner_bezier_curve(map->Points, vertex, uu, 4, map->Order);
  1960.   }
  1961.   else if (ctx->Eval.Map1Vertex3) 
  1962.   {
  1963.      struct gl_1d_map *map = &ctx->EvalMap.Map1Vertex3;
  1964.      uu = (u - map->u1) / (map->u2 - map->u1);
  1965.      horner_bezier_curve(map->Points, vertex, uu, 3, map->Order);
  1966.      vertex[3] = 1.0;
  1967.   }
  1968.  
  1969.   /** Color Index **/
  1970.   if (ctx->Eval.Map1Index) 
  1971.   {
  1972.      struct gl_1d_map *map = &ctx->EvalMap.Map1Index;
  1973.      GLfloat findex;
  1974.      uu = (u - map->u1) / (map->u2 - map->u1);
  1975.      horner_bezier_curve(map->Points, &findex, uu, 1, map->Order);
  1976.      index = (GLuint) (GLint) findex;
  1977.   }
  1978.   else {
  1979.      index = ctx->Current.Index;
  1980.   }
  1981.  
  1982.   /** Color **/
  1983.   if (ctx->Eval.Map1Color4) {
  1984.      struct gl_1d_map *map = &ctx->EvalMap.Map1Color4;
  1985.      uu = (u - map->u1) / (map->u2 - map->u1);
  1986.      horner_bezier_curve(map->Points, fcolor, uu, 4, map->Order);
  1987.      icolor[0] = (GLint) (fcolor[0] * ctx->Visual->RedScale);
  1988.      icolor[1] = (GLint) (fcolor[1] * ctx->Visual->GreenScale);
  1989.      icolor[2] = (GLint) (fcolor[2] * ctx->Visual->BlueScale);
  1990.      icolor[3] = (GLint) (fcolor[3] * ctx->Visual->AlphaScale);
  1991.      colorptr = icolor;
  1992.   }
  1993.   else {
  1994.      colorptr = ctx->Current.IntColor;
  1995.   }
  1996.  
  1997.   /** Normal Vector **/
  1998.   if (ctx->Eval.Map1Normal) {
  1999.      struct gl_1d_map *map = &ctx->EvalMap.Map1Normal;
  2000.      uu = (u - map->u1) / (map->u2 - map->u1);
  2001.      horner_bezier_curve(map->Points, normal, uu, 3, map->Order);
  2002.   }
  2003.   else {
  2004.     normal[0] = ctx->Current.Normal[0];
  2005.     normal[1] = ctx->Current.Normal[1];
  2006.     normal[2] = ctx->Current.Normal[2];
  2007.   }
  2008.  
  2009.   /** Texture Coordinates **/
  2010.   if (ctx->Eval.Map1TextureCoord4) {
  2011.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture4;
  2012.      uu = (u - map->u1) / (map->u2 - map->u1);
  2013.      horner_bezier_curve(map->Points, texcoord, uu, 4, map->Order);
  2014.   }
  2015.   else if (ctx->Eval.Map1TextureCoord3) {
  2016.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture3;
  2017.      uu = (u - map->u1) / (map->u2 - map->u1);
  2018.      horner_bezier_curve(map->Points, texcoord, uu, 3, map->Order);
  2019.      texcoord[3] = 1.0;
  2020.   }
  2021.   else if (ctx->Eval.Map1TextureCoord2) {
  2022.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture2;
  2023.      uu = (u - map->u1) / (map->u2 - map->u1);
  2024.      horner_bezier_curve(map->Points, texcoord, uu, 2, map->Order);
  2025.      texcoord[2] = 0.0;
  2026.      texcoord[3] = 1.0;
  2027.   }
  2028.   else if (ctx->Eval.Map1TextureCoord1) {
  2029.      struct gl_1d_map *map = &ctx->EvalMap.Map1Texture1;
  2030.      uu = (u - map->u1) / (map->u2 - map->u1);
  2031.      horner_bezier_curve(map->Points, texcoord, uu, 1, map->Order);
  2032.      texcoord[1] = 0.0;
  2033.      texcoord[2] = 0.0;
  2034.      texcoord[3] = 1.0;
  2035.   }
  2036.   else {
  2037.      texcoord[0] = ctx->Current.TexCoord[0];
  2038.      texcoord[1] = ctx->Current.TexCoord[1];
  2039.      texcoord[2] = ctx->Current.TexCoord[2];
  2040.      texcoord[3] = ctx->Current.TexCoord[3];
  2041.   }
  2042.   
  2043.   gl_eval_vertex( ctx, vertex, normal, colorptr, index, texcoord );
  2044. }
  2045.  
  2046.  
  2047. void gl_EvalCoord2f( GLcontext* ctx, GLfloat u, GLfloat v )
  2048. {
  2049.    GLfloat vertex[4];
  2050.    GLfloat normal[3];
  2051.    GLfloat fcolor[4];
  2052.    GLint icolor[4];
  2053.    GLint *colorptr;
  2054.    GLfloat texcoord[4];
  2055.    GLuint index;
  2056.    register GLfloat uu, vv;
  2057.  
  2058. #define CROSS_PROD(n, u, v) \
  2059.   (n)[0] = (u)[1]*(v)[2] - (u)[2]*(v)[1]; \
  2060.   (n)[1] = (u)[2]*(v)[0] - (u)[0]*(v)[2]; \
  2061.   (n)[2] = (u)[0]*(v)[1] - (u)[1]*(v)[0]
  2062. #define NORMALIZE(n) \
  2063.   { GLfloat l = sqrt((n)[0]*(n)[0] + (n)[1]*n[1] + (n)[2]*(n)[2]); \
  2064.     if(l > 0.000001) { (n)[0]/=l; (n)[1]/=l; (n)[2]/=l; } }
  2065.  
  2066.    /** Vertex **/
  2067.    if(ctx->Eval.Map2Vertex4) {
  2068.       struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex4;
  2069.       uu = (u - map->u1) / (map->u2 - map->u1);
  2070.       vv = (v - map->v1) / (map->v2 - map->v1);
  2071.  
  2072.       if (ctx->Eval.AutoNormal) {
  2073.          GLfloat du[4], dv[4];
  2074.  
  2075.          de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 4,
  2076.                            map->Uorder, map->Vorder);
  2077.  
  2078.          CROSS_PROD(normal, du, dv);
  2079.          NORMALIZE(normal);
  2080.       }
  2081.       else {
  2082.          horner_bezier_surf(map->Points, vertex, uu, vv, 4,
  2083.                             map->Uorder, map->Vorder);
  2084.       }
  2085.    }
  2086.    else if (ctx->Eval.Map2Vertex3) {
  2087.       struct gl_2d_map *map = &ctx->EvalMap.Map2Vertex3;
  2088.       uu = (u - map->u1) / (map->u2 - map->u1);
  2089.       vv = (v - map->v1) / (map->v2 - map->v1);
  2090.       if (ctx->Eval.AutoNormal) {
  2091.          GLfloat du[3], dv[3];
  2092.          de_casteljau_surf(map->Points, vertex, du, dv, uu, vv, 3,
  2093.                            map->Uorder, map->Vorder);
  2094.          CROSS_PROD(normal, du, dv);
  2095.          NORMALIZE(normal);
  2096.       }
  2097.       else {
  2098.          horner_bezier_surf(map->Points, vertex, uu, vv, 3,
  2099.                             map->Uorder, map->Vorder);
  2100.       }
  2101.       vertex[3] = 1.0;
  2102.    }
  2103. #undef NORMALIZE
  2104. #undef CROSS_PROD
  2105.    
  2106.    /** Color Index **/
  2107.    if (ctx->Eval.Map2Index) {
  2108.       GLfloat findex;
  2109.       struct gl_2d_map *map = &ctx->EvalMap.Map2Index;
  2110.       uu = (u - map->u1) / (map->u2 - map->u1);
  2111.       vv = (v - map->v1) / (map->v2 - map->v1);
  2112.       horner_bezier_surf(map->Points, &findex, uu, vv, 1,
  2113.                          map->Uorder, map->Vorder);
  2114.       index = (GLuint) (GLint) findex;
  2115.    }
  2116.    else {
  2117.       index = ctx->Current.Index;
  2118.    }
  2119.  
  2120.    /** Color **/
  2121.    if (ctx->Eval.Map2Color4) {
  2122.       struct gl_2d_map *map = &ctx->EvalMap.Map2Color4;
  2123.       uu = (u - map->u1) / (map->u2 - map->u1);
  2124.       vv = (v - map->v1) / (map->v2 - map->v1);
  2125.       horner_bezier_surf(map->Points, fcolor, uu, vv, 4,
  2126.                          map->Uorder, map->Vorder);
  2127.       icolor[0] = (GLint) (fcolor[0] * ctx->Visual->RedScale);
  2128.       icolor[1] = (GLint) (fcolor[1] * ctx->Visual->GreenScale);
  2129.       icolor[2] = (GLint) (fcolor[2] * ctx->Visual->BlueScale);
  2130.       icolor[3] = (GLint) (fcolor[3] * ctx->Visual->AlphaScale);
  2131.       colorptr = icolor;
  2132.    }
  2133.    else {
  2134.       colorptr = ctx->Current.IntColor;
  2135.    }
  2136.  
  2137.    /** Normal **/
  2138.    if (!ctx->Eval.AutoNormal
  2139.        || (!ctx->Eval.Map2Vertex3 && !ctx->Eval.Map2Vertex4)) {
  2140.       if (ctx->Eval.Map2Normal) {
  2141.          struct gl_2d_map *map = &ctx->EvalMap.Map2Normal;
  2142.          uu = (u - map->u1) / (map->u2 - map->u1);
  2143.          vv = (v - map->v1) / (map->v2 - map->v1);
  2144.          horner_bezier_surf(map->Points, normal, uu, vv, 3,
  2145.                             map->Uorder, map->Vorder);
  2146.       }
  2147.       else {
  2148.          normal[0] = ctx->Current.Normal[0];
  2149.          normal[1] = ctx->Current.Normal[1];
  2150.          normal[2] = ctx->Current.Normal[2];
  2151.       }
  2152.    }
  2153.  
  2154.    /** Texture Coordinates **/
  2155.    if (ctx->Eval.Map2TextureCoord4) {
  2156.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture4;
  2157.       uu = (u - map->u1) / (map->u2 - map->u1);
  2158.       vv = (v - map->v1) / (map->v2 - map->v1);
  2159.       horner_bezier_surf(map->Points, texcoord, uu, vv, 4,
  2160.                          map->Uorder, map->Vorder);
  2161.    }
  2162.    else if (ctx->Eval.Map2TextureCoord3) {
  2163.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture3;
  2164.       uu = (u - map->u1) / (map->u2 - map->u1);
  2165.       vv = (v - map->v1) / (map->v2 - map->v1);
  2166.       horner_bezier_surf(map->Points, texcoord, uu, vv, 3,
  2167.                          map->Uorder, map->Vorder);
  2168.      texcoord[3] = 1.0;
  2169.    }
  2170.    else if (ctx->Eval.Map2TextureCoord2) {
  2171.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture2;
  2172.       uu = (u - map->u1) / (map->u2 - map->u1);
  2173.       vv = (v - map->v1) / (map->v2 - map->v1);
  2174.       horner_bezier_surf(map->Points, texcoord, uu, vv, 2,
  2175.                          map->Uorder, map->Vorder);
  2176.      texcoord[2] = 0.0;
  2177.      texcoord[3] = 1.0;
  2178.    }
  2179.    else if (ctx->Eval.Map2TextureCoord1) {
  2180.       struct gl_2d_map *map = &ctx->EvalMap.Map2Texture1;
  2181.       uu = (u - map->u1) / (map->u2 - map->u1);
  2182.       vv = (v - map->v1) / (map->v2 - map->v1);
  2183.       horner_bezier_surf(map->Points, texcoord, uu, vv, 1,
  2184.                          map->Uorder, map->Vorder);
  2185.      texcoord[1] = 0.0;
  2186.      texcoord[2] = 0.0;
  2187.      texcoord[3] = 1.0;
  2188.    }
  2189.    else 
  2190.    {
  2191.      texcoord[0] = ctx->Current.TexCoord[0];
  2192.      texcoord[1] = ctx->Current.TexCoord[1];
  2193.      texcoord[2] = ctx->Current.TexCoord[2];
  2194.      texcoord[3] = ctx->Current.TexCoord[3];
  2195.    }
  2196.  
  2197.    gl_eval_vertex( ctx, vertex, normal, colorptr, index, texcoord );
  2198. }
  2199.  
  2200.  
  2201. void gl_MapGrid1f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2 )
  2202. {
  2203.    if (INSIDE_BEGIN_END(ctx)) {
  2204.       gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid1f" );
  2205.       return;
  2206.    }
  2207.    if (un<1) {
  2208.       gl_error( ctx, GL_INVALID_VALUE, "glMapGrid1f" );
  2209.       return;
  2210.    }
  2211.    ctx->Eval.MapGrid1un = un;
  2212.    ctx->Eval.MapGrid1u1 = u1;
  2213.    ctx->Eval.MapGrid1u2 = u2;
  2214. }
  2215.  
  2216.  
  2217. void gl_MapGrid2f( GLcontext* ctx, GLint un, GLfloat u1, GLfloat u2,
  2218.           GLint vn, GLfloat v1, GLfloat v2 )
  2219. {
  2220.    if (INSIDE_BEGIN_END(ctx)) {
  2221.       gl_error( ctx, GL_INVALID_OPERATION, "glMapGrid2f" );
  2222.       return;
  2223.    }
  2224.    if (un<1) {
  2225.       gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(un)" );
  2226.       return;
  2227.    }
  2228.    if (vn<1) {
  2229.       gl_error( ctx, GL_INVALID_VALUE, "glMapGrid2f(vn)" );
  2230.       return;
  2231.    }
  2232.    ctx->Eval.MapGrid2un = un;
  2233.    ctx->Eval.MapGrid2u1 = u1;
  2234.    ctx->Eval.MapGrid2u2 = u2;
  2235.    ctx->Eval.MapGrid2vn = vn;
  2236.    ctx->Eval.MapGrid2v1 = v1;
  2237.    ctx->Eval.MapGrid2v2 = v2;
  2238. }
  2239.  
  2240.  
  2241. void gl_EvalPoint1( GLcontext* ctx, GLint i )
  2242. {
  2243.     GLfloat u, du;
  2244.  
  2245.     if (i==0) {
  2246.         u = ctx->Eval.MapGrid1u1;
  2247.     }
  2248.     else if (i==ctx->Eval.MapGrid1un) {
  2249.         u = ctx->Eval.MapGrid1u2;
  2250.     }
  2251.     else {
  2252.         du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
  2253.             / (GLfloat) ctx->Eval.MapGrid1un;
  2254.         u = i * du + ctx->Eval.MapGrid1u1;
  2255.     }
  2256.     gl_EvalCoord1f( ctx, u );
  2257. }
  2258.  
  2259.  
  2260.  
  2261. void gl_EvalPoint2( GLcontext* ctx, GLint i, GLint j )
  2262. {
  2263.     GLfloat u, du;
  2264.     GLfloat v, dv;
  2265.  
  2266.     if (i==0) {
  2267.         u = ctx->Eval.MapGrid2u1;
  2268.     }
  2269.     else if (i==ctx->Eval.MapGrid2un) {
  2270.         u = ctx->Eval.MapGrid2u2;
  2271.     }
  2272.     else {
  2273.         du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
  2274.             / (GLfloat) ctx->Eval.MapGrid2un;
  2275.         u = i * du + ctx->Eval.MapGrid2u1;
  2276.     }
  2277.  
  2278.     if (j==0) {
  2279.         v = ctx->Eval.MapGrid2v1;
  2280.     }
  2281.     else if (j==ctx->Eval.MapGrid2vn) {
  2282.         v = ctx->Eval.MapGrid2v2;
  2283.     }
  2284.     else {
  2285.         dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
  2286.             / (GLfloat) ctx->Eval.MapGrid2vn;
  2287.         v = j * dv + ctx->Eval.MapGrid2v1;
  2288.     }
  2289.  
  2290.     gl_EvalCoord2f( ctx, u, v );
  2291. }
  2292.  
  2293.  
  2294.  
  2295. void gl_EvalMesh1( GLcontext* ctx, GLenum mode, GLint i1, GLint i2 )
  2296. {
  2297.    GLint i;
  2298.    GLfloat u, du;
  2299.    GLenum prim;
  2300.  
  2301.     if (INSIDE_BEGIN_END(ctx)) {
  2302.         gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh1" );
  2303.         return;
  2304.     }
  2305.  
  2306.     switch (mode) {
  2307.     case GL_POINT:
  2308.         prim = GL_POINTS;
  2309.         break;
  2310.     case GL_LINE:
  2311.         prim = GL_LINE_STRIP;
  2312.         break;
  2313.     default:
  2314.         gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh1(mode)" );
  2315.         return;
  2316.     }
  2317.  
  2318.     du = (ctx->Eval.MapGrid1u2 - ctx->Eval.MapGrid1u1)
  2319.         / (GLfloat) ctx->Eval.MapGrid1un;
  2320.  
  2321.     gl_Begin( ctx, prim );
  2322.     for (i=i1;i<=i2;i++) {
  2323.         if (i==0) {
  2324.             u = ctx->Eval.MapGrid1u1;
  2325.         }
  2326.         else if (i==ctx->Eval.MapGrid1un) {
  2327.             u = ctx->Eval.MapGrid1u2;
  2328.         }
  2329.         else {
  2330.             u = i * du + ctx->Eval.MapGrid1u1;
  2331.         }
  2332.         gl_EvalCoord1f( ctx, u );
  2333.     }
  2334.     gl_End(ctx);
  2335. }
  2336.  
  2337.  
  2338.  
  2339. void gl_EvalMesh2( GLcontext* ctx, GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
  2340. {
  2341.     GLint i, j;
  2342.     GLfloat u, du, v, dv, v1, v2;
  2343.  
  2344.     if (INSIDE_BEGIN_END(ctx)) {
  2345.         gl_error( ctx, GL_INVALID_OPERATION, "glEvalMesh2" );
  2346.         return;
  2347.     }
  2348.  
  2349.     du = (ctx->Eval.MapGrid2u2 - ctx->Eval.MapGrid2u1)
  2350.         / (GLfloat) ctx->Eval.MapGrid2un;
  2351.     dv = (ctx->Eval.MapGrid2v2 - ctx->Eval.MapGrid2v1)
  2352.         / (GLfloat) ctx->Eval.MapGrid2vn;
  2353.  
  2354. #define I_TO_U( I, U )                \
  2355.     if ((I)==0) {                   \
  2356.         U = ctx->Eval.MapGrid2u1;        \
  2357.     }                    \
  2358.     else if ((I)==ctx->Eval.MapGrid2un) {    \
  2359.         U = ctx->Eval.MapGrid2u2;        \
  2360.     }                    \
  2361.     else {                \
  2362.         U = (I) * du + ctx->Eval.MapGrid2u1;\
  2363.     }
  2364.  
  2365. #define J_TO_V( J, V )                \
  2366.     if ((J)==0) {            \
  2367.         V = ctx->Eval.MapGrid2v1;        \
  2368.     }                    \
  2369.     else if ((J)==ctx->Eval.MapGrid2vn) {    \
  2370.         V = ctx->Eval.MapGrid2v2;        \
  2371.     }                    \
  2372.     else {                \
  2373.         V = (J) * dv + ctx->Eval.MapGrid2v1;\
  2374.     }
  2375.  
  2376.     switch (mode) {
  2377.     case GL_POINT:
  2378.         gl_Begin( ctx, GL_POINTS );
  2379.         for (j=j1;j<=j2;j++) {
  2380.             J_TO_V( j, v );
  2381.             for (i=i1;i<=i2;i++) {
  2382.                 I_TO_U( i, u );
  2383.                 gl_EvalCoord2f( ctx, u, v );
  2384.             }
  2385.         }
  2386.         gl_End(ctx);
  2387.         break;
  2388.     case GL_LINE:
  2389.         for (j=j1;j<=j2;j++) {
  2390.             J_TO_V( j, v );
  2391.             gl_Begin( ctx, GL_LINE_STRIP );
  2392.             for (i=i1;i<=i2;i++) {
  2393.                 I_TO_U( i, u );
  2394.                 gl_EvalCoord2f( ctx, u, v );
  2395.             }
  2396.             gl_End(ctx);
  2397.         }
  2398.         for (i=i1;i<=i2;i++) {
  2399.             I_TO_U( i, u );
  2400.             gl_Begin( ctx, GL_LINE_STRIP );
  2401.             for (j=j1;j<=j2;j++) {
  2402.                 J_TO_V( j, v );
  2403.                 gl_EvalCoord2f( ctx, u, v );
  2404.             }
  2405.             gl_End(ctx);
  2406.         }
  2407.         break;
  2408.     case GL_FILL:
  2409.         for (j=j1;j<j2;j++) {
  2410.             /* NOTE: a quad strip can't be used because the four */
  2411.             /* can't be guaranteed to be coplanar! */
  2412.             gl_Begin( ctx, GL_TRIANGLE_STRIP );
  2413.             J_TO_V( j, v1 );
  2414.             J_TO_V( j+1, v2 );
  2415.             for (i=i1;i<=i2;i++) {
  2416.                 I_TO_U( i, u );
  2417.                 gl_EvalCoord2f( ctx, u, v1 );
  2418.                 gl_EvalCoord2f( ctx, u, v2 );
  2419.             }
  2420.             gl_End(ctx);
  2421.         }
  2422.         break;
  2423.     default:
  2424.         gl_error( ctx, GL_INVALID_ENUM, "glEvalMesh2(mode)" );
  2425.         return;
  2426.     }
  2427.  
  2428. #undef I_TO_U
  2429. #undef J_TO_V
  2430. }
  2431.  
  2432.